Package: C4SolutionAnalyzerHorizontal

C4SolutionAnalyzerHorizontal

name	instruction	branch	complexity	line	method
C4SolutionAnalyzerHorizontal(C4BoardSlim)	M: 0 C: 9 100%	M: 0 C: 0 100%	M: 0 C: 1 100%	M: 0 C: 3 100%	M: 0 C: 1 100%
findAllSolutions(Set, boolean)	M: 0 C: 91 100%	M: 0 C: 18 100%	M: 0 C: 10 100%	M: 0 C: 22 100%	M: 0 C: 1 100%
resetCache()	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%
scanRemaining(int, int, int)	M: 0 C: 31 100%	M: 0 C: 4 100%	M: 0 C: 3 100%	M: 0 C: 5 100%	M: 0 C: 1 100%
tryFindFirstSolution(IC4SolutionSlim, boolean)	M: 2 C: 79 98%	M: 1 C: 17 94%	M: 1 C: 9 90%	M: 1 C: 17 94%	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 horizontally (rows).
14: */
15: public class C4SolutionAnalyzerHorizontal extends C4SolutionAnalyzer {
16:
17: /**
18: * The last row which is updated while searching for a solution to
19: * speed up the search process.
20: */
21: private int optimizedRowMax;
22:
23: /**
24: * Creates a new {@link C4SolutionAnalyzerHorizontal}.
25: * @param board The board to analyze.
26: */
27: public C4SolutionAnalyzerHorizontal(final C4BoardSlim board) {
28: super(board, C4Direction.EAST);
29: optimizedRowMax = super.rowMax();
30: }
31:
32: @Override
33: public IC4SolutionSlim tryFindFirstSolution(final IC4SolutionSlim currentSolution, final boolean updateCache) {
34:
35:• if (currentSolution != null) {
36: return currentSolution;
37: }
38:
39: boolean isRowEmpty = false;
40: // count row by row, EAST from bottom to top for faster matches
41: // abort as soon as we reach an empty row (gravity)
42:• for (int row = this.optimizedRowMax - 1; row >= 0 && !isRowEmpty; row--) {
43: int token;
44: int lastToken = 0;
45: int count = 0;
46: isRowEmpty = true;
47: boolean isRowFull = true;
48:• for (int col = 0; col < colMax(); col++, lastToken = token) {
49: token = board().getTokenUnsafe(row, col);
50: count = countConsecutivesBranchless(count, token, lastToken);
51:• if (count >= targetCount()) {
52: return scanRemaining(token, row, col);
53: }
54:• isRowFull &= token != EMPTY_TOKEN;
55:• isRowEmpty &= token == EMPTY_TOKEN;
56: }
57: // if the current row is full and contains no solution we can remember that
58: // and don't have to re-evaluate that row next time
59:• if (updateCache && isRowFull) {
60: this.optimizedRowMax = row;
61: }
62: }
63: return null;
64: }
65:
66: @Override
67: public void findAllSolutions(final Set<IC4SolutionSlim> resultSet, final boolean updateCache) {
68: // count row by row, EAST from bottom to top for faster matches
69: boolean isRowEmpty = false;
70:• for (int row = this.optimizedRowMax - 1; row >= 0 && !isRowEmpty; row--) {
71: isRowEmpty = true;
72: int token;
73: int lastToken = 0;
74: int count = 0;
75: boolean isRowFull = true;
76: boolean rowContainsSolution = false;
77: int col = 0;
78:• for (; col < colMax(); col++, lastToken = token) {
79: token = board().getTokenUnsafe(row, col);
80: count = countConsecutivesBranchless(count, token, lastToken);
81:• if (count >= targetCount()) {
82: count = 0;
83: final C4SolutionSlim solution = scanRemaining(token, row, col);
84: resultSet.add(solution);
85: rowContainsSolution = true;
86: // skip to the end of the solution
87: col = solution.getColumnIndexEnd();
88: }
89:• isRowFull &= token != EMPTY_TOKEN;
90:• isRowEmpty &= token == EMPTY_TOKEN;
91: }
92: // if the current row is full and contains no solution we can remember that
93: // and don't have to re-evaluate that row the next time
94:• if (updateCache && isRowFull && !rowContainsSolution) {
95: this.optimizedRowMax = row;
96: }
97: }
98: }
99:
100: @Override
101: protected C4SolutionSlim scanRemaining(final int token, final int startRow, final int startCol) {
102: int col = startCol + 1;
103:• while (col < colMax() && board().getTokenUnsafe(startRow, col) == token) {
104: col++;
105: }
106: // revert last change to get inclusive upper bound
107: col--;
108: return solutionOf(token, startRow, col, board().getMinimumSolutionSize() + col - startCol);
109: }
110:
111: @Override
112: public void resetCache() {
113: this.optimizedRowMax = super.rowMax();
114: }
115: }