Package: C4SolutionAnalyzerDiagonalRight

C4SolutionAnalyzerDiagonalRight

name	instruction	branch	complexity	line	method
C4SolutionAnalyzerDiagonalRight(C4BoardSlim)	M: 0 C: 5 100%	M: 0 C: 0 100%	M: 0 C: 1 100%	M: 0 C: 2 100%	M: 0 C: 1 100%
findAllSolutions(Set, boolean)	M: 0 C: 53 100%	M: 2 C: 6 75%	M: 2 C: 3 60%	M: 0 C: 8 100%	M: 0 C: 1 100%
findAllSolutions(Set, int, int, int, boolean)	M: 0 C: 74 100%	M: 0 C: 14 100%	M: 0 C: 8 100%	M: 0 C: 21 100%	M: 0 C: 1 100%
scanRemaining(int, int, int)	M: 0 C: 37 100%	M: 0 C: 6 100%	M: 0 C: 4 100%	M: 0 C: 8 100%	M: 0 C: 1 100%
tryFindFirstSolution(IC4SolutionSlim, boolean)	M: 0 C: 60 100%	M: 2 C: 10 83%	M: 2 C: 5 71%	M: 0 C: 9 100%	M: 0 C: 1 100%
tryFindFirstSolution(int, int, int, boolean)	M: 3 C: 54 95%	M: 1 C: 11 92%	M: 1 C: 6 86%	M: 1 C: 14 93%	M: 0 C: 1 100%

Coverage

1: package de.fhdw.gaming.ipspiel23.c4.domain.impl.evaluation;
2:
3: import java.util.Set;
4:
5: import de.fhdw.gaming.ipspiel23.c4.domain.C4Direction;
6: import de.fhdw.gaming.ipspiel23.c4.domain.IC4SolutionSlim;
7: import de.fhdw.gaming.ipspiel23.c4.domain.impl.C4BoardSlim;
8: import de.fhdw.gaming.ipspiel23.c4.domain.impl.C4SolutionSlim;
9:
10: import static de.fhdw.gaming.ipspiel23.c4.domain.impl.C4BoardSlim.EMPTY_TOKEN;
11:
12: /**
13: * A {@link C4SolutionAnalyzer} that analyzes the board on the diagonal from the top left to the bottom right.
14: */
15: public class C4SolutionAnalyzerDiagonalRight extends C4SolutionAnalyzerDiagonal {
16:
17: /**
18: * Creates a new {@link C4SolutionAnalyzerDiagonalRight}.
19: * @param board The board to analyze.
20: */
21: public C4SolutionAnalyzerDiagonalRight(final C4BoardSlim board) {
22: super(board, C4Direction.NORTH_WEST);
23: }
24:
25: @Override
26: public IC4SolutionSlim tryFindFirstSolution(final IC4SolutionSlim currentSolution, final boolean updateCache) {
27: // "Assignment of parameter 'currentSolution' is not allowed." :P
28: IC4SolutionSlim solution = currentSolution;
29:
30: int iteration = 0;
31: // determine start row of the last column (skip first targetCount rows as the will never contain a solution)
32:• for (int startRow = targetCount(); solution == null && startRow < rowMax(); startRow++, iteration++) {
33:• if (mayContainSolution(iteration)) {
34: solution = tryFindFirstSolution(startRow, colMax() - 1, iteration, updateCache);
35: }
36: }
37: // determine start column of last row (ignore first targetCount columns as the will never contain a solution)
38: // don't evaluate diagonal starting in bottom right twice (startCol = colMax - 2)
39:• for (int startCol = colMax() - 2; solution == null && startCol >= targetCount(); startCol--, iteration++) {
40:• if (mayContainSolution(iteration)) {
41: solution = tryFindFirstSolution(rowMax() - 1, startCol, iteration, updateCache);
42: }
43: }
44: return solution;
45: }
46:
47: /**
48: * Lazily searches for the first solution on the board starting at the specified position.
49: * @param startRow the row to start at
50: * @param startCol the column to start at
51: * @param iteration the current iteration of the search
52: * @param updateCache whether to update the solution cache, preventing the same line to be checked again
53: * @return The first solution on the board or null if no solution was found.
54: */
55: private IC4SolutionSlim tryFindFirstSolution(final int startRow, final int startCol,
56: final int iteration, final boolean updateCache) {
57: int count = 0;
58: int lastToken = 0;
59: boolean isDiagonalFull = true;
60: // "ForLoopVariableCount: Too many control variables in the for statement" :P
61: int row = startRow;
62: int col = startCol;
63:• for (; row >= 0 && col >= 0; row--, col--) {
64: final int token = board().getTokenUnsafe(row, col);
65: count = countConsecutivesBranchless(count, token, lastToken);
66:• if (count >= targetCount()) {
67: return scanRemaining(token, row, col);
68: }
69:• isDiagonalFull &= token != EMPTY_TOKEN;
70: lastToken = token;
71: }
72:• if (updateCache && isDiagonalFull) {
73: noSolutionIn(iteration);
74: }
75: return null;
76: }
77:
78: @Override
79: public void findAllSolutions(final Set<IC4SolutionSlim> resultSet, final boolean updateCache) {
80: int iteration = 0;
81: // determine start row of the last column (skip first targetCount rows)
82:• for (int startRow = targetCount(); startRow < rowMax(); startRow++, iteration++) {
83:• if (mayContainSolution(iteration)) {
84: findAllSolutions(resultSet, startRow, colMax() - 1, iteration, updateCache);
85: }
86: }
87: // determine start column of last row (ignore first targetCount columns)
88: // don't evaluate diagonal starting in bottom right twice (startCol = colMax - 2)
89:• for (int startCol = colMax() - 2; startCol >= targetCount(); startCol--, iteration++) {
90:• if (mayContainSolution(iteration)) {
91: findAllSolutions(resultSet, rowMax() - 1, startCol, iteration, updateCache);
92: }
93: }
94: }
95:
96: /**
97: * Eagerly searches for all solutions on the board starting at the specified position.
98: * @param resultSet the set to which any solutions are added
99: * @param startRow the row to start at
100: * @param startCol the column to start at
101: * @param iteration the current iteration of the search
102: * @param updateCache whether to update the solution cache, preventing the same line to be checked again
103: */
104: private void findAllSolutions(final Set<IC4SolutionSlim> resultSet, final int startRow,
105: final int startCol, final int iteration, final boolean updateCache) {
106: int count = 0;
107: int lastToken = 0;
108: boolean isDiagonalFull = true;
109: boolean diagonalContainsSolution = false;
110: // "ForLoopVariableCount: Too many control variables in the for statement" :P
111: int row = startRow;
112: int col = startCol;
113:• for (; row >= 0 && col >= 0; row--, col--) {
114: final int token = board().getTokenUnsafe(row, col);
115: count = countConsecutivesBranchless(count, token, lastToken);
116:• if (count >= targetCount()) {
117: count = 0;
118: final C4SolutionSlim solution = scanRemaining(token, row, col);
119: resultSet.add(solution);
120: diagonalContainsSolution = true;
121: // skip to end of solution
122: row = solution.getRowIndexEnd();
123: col = solution.getColumnIndexEnd();
124: }
125:• isDiagonalFull &= token != EMPTY_TOKEN;
126: lastToken = token;
127: }
128:• if (updateCache && isDiagonalFull && !diagonalContainsSolution) {
129: noSolutionIn(iteration);
130: }
131: }
132:
133: @Override
134: protected C4SolutionSlim scanRemaining(final int token, final int startRow, final int startCol) {
135: int row = startRow - 1;
136: int col = startCol - 1;
137:• while (row >= 0 && col >= 0 && board().getTokenUnsafe(row, col) == token) {
138: row--;
139: col--;
140: }
141: // revert last change to get inclusive upper bound
142: row++;
143: col++;
144: return solutionOf(token, row, col, board().getMinimumSolutionSize() + startRow - row);
145: }
146: }