SudokuModel_B

package csc143.sudoku;

import javax.swing.*;
import csc143.sudoku.*;
import java.awt.*;
import java.util.*;

/**
 * @author Vita Wiebe
 * @version PAx: Sudoku Serialization and Make-Up
 * A class extending SudokuCore, which in turn extends
 * SudokuBase.
 */
public class SudokuModel extends SudokuCore {

    /** Our class constructor.
     * @param int r, int c
     */
    public SudokuModel(int r, int c) {
        super(r, c);
        int size = super.getSize();
    }

    // Goes thru cellCoordinates[][] row index # n and determines
    // whether row is complete, incomplete, or contains duplicates (error)
    public State getRowState(int n) {

        // columns are total number for this game board
        int columns = this.getColumns();
        int size = this.getSize();
        int gridSorted[] = new int [size];

        // Put the germane range of values from super.grid[] into
        // gridSorted[] (depending on row we're examining).
        for(int i = 0; i < size; i++) {

            for(int col = 0; col < columns; col++) {

                gridSorted[i] = super.getValue(n, col);
            }
        }

        // Sort the values from grid/gridSorted associated
        // with row # n of cellCoordinates[][].
        Arrays.sort(gridSorted);

        // hasEmpty is a flag to store when an empty
        // element has been found.
        boolean hasEmpty = false;
        if(gridSorted[0] == 0) {
            hasEmpty = true;
        }

        // Iterate thru gridSorted, looking for empties
        // and duplicate values.
        for(int j = 1; j < gridSorted.length; j++) {
            if(gridSorted[j] == gridSorted[j - 1]) {
                return State.ERROR;
            } else if(gridSorted[j] == 0) {
                hasEmpty = true;
            }
        }
        if(hasEmpty) {
            return State.INCOMPLETE;
        }
        return State.COMPLETE;
    }

   // Need to go thru cellCoordinates[][] column index # n and determine
   // whether column is complete, incomplete, or contains duplicates (error).
   public State getColumnState(int n) {

        // Rows is the total number of rows on the board
        int rows = this.getRows();
        int size = this.getSize();

        // Create a copy of grid[], our superclass's array for holdinig
        // the values of each cell on the board.
        int gridSorted[] = new int[size];

        // Put the germane range of values from super.grid[] into
        // gridSorted[] (depending on column we're examining).
        for(int i = 0; i < size; i++) {

            for(int row = 0; row < rows; row++) {

                gridSorted[i] = super.getValue(row, n);
            }
        }

        // Sort the values from grid/gridSorted associated
        // with column # n of cellCoordinates[][].
        Arrays.sort(gridSorted);

        // hasEmpty is a flag to store when an empty
        // element has been found.
        boolean hasEmpty = false;
        if(gridSorted[0] == 0) {
            hasEmpty = true;
        }

        // Iterate thru gridSorted, looking for empties
        // and duplicate values.
        for(int j = 1; j < gridSorted.length; j++) {
            if(super.getValue(row, n) == 0) {
                return State.INCOMPLETE;
            } else if(super.getValue(row, n) == (super.getValue(row - 1, n))) {
                return State.ERROR;
            }
        }
        return State.COMPLETE;
    }

    public State getRegionState(int n) {

    return State.COMPLETE;
    }

}