com.mike.angry.dm.Digital.java Source code

Introduction

Here is the source code for com.mike.angry.dm.Digital.java

Source

/**
 * Project: ShuduSolver
 * 
 * File Created at 2013-5-10
 * $Id$
 * 
 * Copyright 1999-2100 Alibaba.com Corporation Limited.
 * All rights reserved.
 *
 * This software is the confidential and proprietary information of
 * Alibaba Company. ("Confidential Information").  You shall not
 * disclose such Confidential Information and shall use it only in
 * accordance with the terms of the license agreement you entered into
 * with Alibaba.com.
 */
package com.mike.angry.dm;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.springframework.util.Assert;

import com.mike.angry.dm.common.util.ListHelper;
import com.mike.angry.dm.common.util.ShuduSquareChecker;
import com.mike.angry.intelligent.discovery.WrongNumException;

public class Digital {
    // ??
    private boolean isDetermined = false;
    // 
    private int number = 0;
    // ?
    private List<Integer> possibleNums = new ArrayList<Integer>();
    // ?
    {
        for (int i = 1; i <= 9; i++) {
            possibleNums.add(i);
        }
    }

    private int x = 0; // 9*9x??
    private int y = 0; // 9*9y??
    private int squareNum = 0; // ?
    private int squareX = 0; // 3*3x??
    private int squareY = 0; // 3*3Y??

    public Digital(int number, int x, int y, int squareNum, int squareX, int squareY) {
        if (number != 0) {
            this.number = number;
            isDetermined = true;
            possibleNums = new ArrayList<Integer>();
        }
        this.x = x;
        this.y = y;
        this.squareNum = squareNum;
        this.squareX = squareX;
        this.squareY = squareY;
    }

    public boolean isDetermined() {
        return isDetermined;
    }

    public void setDetermined(boolean isDetermined) {
        this.isDetermined = isDetermined;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public List<Integer> getPossibleNums() {
        return possibleNums;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    public int getSquareNum() {
        return squareNum;
    }

    public int getSquareX() {
        return squareX;
    }

    public int getSquareY() {
        return squareY;
    }

    private void rebuild(DataModel dataModel) {
        // ??
        if (possibleNums.size() == 0) {
            throw new WrongNumException(this);
        }
        // 
        if (possibleNums.size() == 1) {
            this.number = possibleNums.get(0);
            isDetermined = true;
            possibleNums = new ArrayList<Integer>();
            if (!ShuduSquareChecker.isValid(this, dataModel)) {
                throw new WrongNumException(this);
            }
        }
    }

    public DigitalResolveResultDO filterByKeep(Integer keepValue, DataModel dataModel) {
        Assert.isTrue(possibleNums.contains(keepValue));

        ArrayList<Integer> newPossibleNums = new ArrayList<Integer>();
        newPossibleNums.add(keepValue);
        return filterByKeep(newPossibleNums, dataModel);
    }

    public DigitalResolveResultDO filterByKeep(List<Integer> keepList, DataModel dataModel) {

        // Debug 
        // if (x == 7 && y == 4) {
        // System.out.println("================================");
        // SolverResultOutput.printResultForDebug(dataModel);
        // System.out.println("================================");
        // }

        if (possibleNums.size() <= keepList.size()) {
            return new DigitalResolveResultDO(this, isDetermined);
        }
        // ??
        List<Integer> listDiffer = ListHelper.getListDiffer(possibleNums, keepList);
        // 
        Collections.sort(keepList);
        possibleNums = ListHelper.listCopy(keepList);
        // ??
        rebuild(dataModel);

        // 
        DigitalResolveResultDO result = new DigitalResolveResultDO(this, isDetermined);
        if (listDiffer.size() != 0) {
            result.setDeducePosibility(true);
            result.setDeduceNums(listDiffer);
        }
        return result;
    }

    @Override
    protected Digital clone() throws CloneNotSupportedException {
        Digital digital = new Digital(number, x, y, squareNum, squareX, squareY);
        digital.isDetermined = this.isDetermined;
        List<Integer> copiedPossibleNums = new ArrayList<Integer>();

        for (Integer one : this.possibleNums) {
            copiedPossibleNums.add(one);
        }
        digital.possibleNums = copiedPossibleNums;

        return digital;
    }

    @Override
    public String toString() {
        return "x=" + x + "\ty=" + y + "\tisDetermated=" + isDetermined + "\tnumber=" + number
                + "\tpossibleNums = {" + possibleNums + "}";

    }
}