/home/marcvs/Desktop/working/pa-materiale/pa/codeBase/C++/include/SudokuBoard.h

#ifndef __SUDOKUBOARD_H__
#define __SUDOKUBOARD_H__

#pragma once

#include <iostream>
#include <fstream>

class SudokuBoard{
private:
        class BitSet{
                private:
                
                        int mem;
                        
                public:
                        BitSet() : mem((9 << 16) | (0x000003FEl)) { }
                        
                        inline int size(){
                                return mem >> 16;
                        }
                        
                        inline bool allows(int i){
                                return (mem & (1 << i));
                        }
                        
                        inline void erase(int i){
                                mem &= (~(1 << i));
                                mem -= (1 << 16);
                        }
                        
                        inline void reduce_to(int i){
                                mem = (1 << 16) | (1 << i);
                        }
                        
                        friend class SudokuBoard;
        };
        
        int filled_in;

        char fill[9][9];

        BitSet row_stats[9];
        BitSet col_stats[9];
        BitSet reg_stats[9];
        
public:
        SudokuBoard();
        
        inline bool impossible(int row, int col){
                return 0 == (0x000003FEl & row_stats[row].mem & col_stats[col].mem & reg_stats[row/3*3+col/3].mem);
        }

        inline int unique_possibility(int row, int col){
                int sol = 0;
                for (int i = 1; i <= 9; i++){
                        if (allows(row, col, i)){
                                if (sol == 0){
                                        sol = i;
                                } else {
                                        return 0;
                                }
                        }
                }
                return sol;
        }

        inline bool allows(int row, int col, int i){
                return row_stats[row].allows(i) && col_stats[col].allows(i) && reg_stats[row/3*3+col/3].allows(i);
        }
        
        inline void put(int row, int col, int i){
                if (!is_empty(row,col)){
                        std::cerr << "ERROR! You must never overwrite values in the Sudoku board!\n";
                        std::cerr << "   Make a copy of the board so you can go back to a previous version!\n";
                        std::cerr << "   Ignoring \"put\" operation!\n";
                        return;
                }
                fill[row][col] = '0' + i;
                row_stats[row].erase(i);
                col_stats[col].erase(i);
                reg_stats[row/3*3+col/3].erase(i);
                filled_in++;
        }

        inline bool is_empty(int row, int col){
                return fill[row][col] == 0;
        }
        
        inline bool is_done(){
                return filled_in == 81;
        }
        
        friend std::ostream& operator<< (std::ostream& out, SudokuBoard& right);
};

std::istream& operator>> (std::istream& in, SudokuBoard& right);

std::ostream& operator<< (std::ostream& out, SudokuBoard& right);

#endif