Conway's Game of Life - A Rule Framework and Implementation

using System.Collections.Generic;

namespace gameOfLife.Framework
{
    /// <summary>
    /// Singleton implementation of ITransitive. 
    /// Only exposed is the ITransitive interface of this class.
    /// </summary>
    public class PatternOfCells : ITransitive
    {
        private IList<Cell> cells = new List<Cell>();

        // threadsafe inialization
        private static ITransitive instance = new PatternOfCells();

        private PatternOfCells()
        {
        }

        /// <summary>
        /// Singleton Instance
        /// </summary>
        public static ITransitive Instance
        {
            get
            {
                // do not need double lock here
                return instance;
            }
        }

        /// <summary>
        /// Apply a set of transitions to this Transitive.
        /// Dead cells should be removed after every set of transition chain
        /// Domain Meaning - A Transitive is something which uses transitions to change its pattern
        /// </summary>
        /// <param name="transitions">list of ITransition implementations</param>
        public void ApplyTransitions(params ITransition[] transitions)
        {
            foreach (ITransition transition in transitions)
            {
                transition.Apply(this);
            }

            ClearDeadCells();
        }

        /// <summary>
        /// Current set of alive (and dead) cells in the pattern.
        /// </summary>
        public IList<Cell> Cells
        {
            get
            {
                return cells;
            }
			set
			{
				cells = value;
			}
        }

        private void ClearDeadCells()
        {
            for (int i = 0; i < Cells.Count; i++)
            {
                if (!Cells[i].IsAlive)
                {
                    Cells.RemoveAt(i--); // decrement i so that there is no miss of current item
                }
            }
        }
    }
}