Example #1
0
 public CalculationContext Create(CalculationContext source)
 {
     if (source == null)
     {
         throw new ArgumentNullException(nameof(source));
     }
     return(Create(source.Grid));
 }
Example #2
0
 private Boolean ProcessSquares(CalculationContext context)
 {
     foreach (GridPoint cell in Defs.Squares)
     {
         if (!Process(_cellsInfoFactory.CreateForSquare(context.Grid, cell), context))
         {
             return(false);
         }
     }
     return(true);
 }
Example #3
0
 private Boolean ProcessColumns(CalculationContext context)
 {
     foreach (Int32 column in Enumerable.Range(1, Defs.GridSide))
     {
         if (!Process(_cellsInfoFactory.CreateForColumn(context.Grid, column), context))
         {
             return(false);
         }
     }
     return(true);
 }
Example #4
0
        private Boolean Process(CellsInfo cellsInfo, CalculationContext context)
        {
            NumbersInfo numbersInfo       = _numbersInfoFactory.Create(cellsInfo);
            Tuple <GridPoint, Int32> data = ChooseCell(cellsInfo, numbersInfo);

            while (data != null)
            {
                context.Grid[data.Item1] = data.Item2;
                context.EmptyCount--;
                UseCell(cellsInfo, numbersInfo, data);
                if (!_checker.Check(cellsInfo, numbersInfo))
                {
                    return(false);
                }
                data = ChooseCell(cellsInfo, numbersInfo);
            }
            return(true);
        }
Example #5
0
        public CalculationResultData Process(CalculationContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }
            CalculationContinuation continuation;

            do
            {
                Int32 emptyCount = context.EmptyCount;
                continuation = ExecuteProcessors(context, ProcessRows, ProcessColumns, ProcessSquares);
                if (context.EmptyCount == 0)
                {
                    continuation = CalculationContinuation.Finish;
                }
                if (emptyCount == context.EmptyCount)
                {
                    continuation = CalculationContinuation.NeedPrediction;
                }
            } while (continuation == CalculationContinuation.Continue);
            return(CreateCalculationResultData(continuation, context));
        }
Example #6
0
 private CalculationContinuation ExecuteProcessors(CalculationContext context, params Func <CalculationContext, Boolean>[] processors)
 {
     return(processors.Any(processor => !processor(context)) ? CalculationContinuation.Stop : CalculationContinuation.Continue);
 }
Example #7
0
        private CalculationResultData CreateCalculationResultData(CalculationContinuation continuation, CalculationContext context)
        {
            switch (continuation)
            {
            case CalculationContinuation.Finish:
                return(new CalculationResultData(CalculationResult.Finish, context));

            case CalculationContinuation.NeedPrediction:
                return(new CalculationResultData(CalculationResult.NeedPrediction, context));

            case CalculationContinuation.Stop:
                return(new CalculationResultData(CalculationResult.Stop, null));

            default:
                throw new InvalidOperationException();
            }
        }