History.cs

using System;
using System.Collections.Generic;
 
namespace be.gaudry.model
{
    public class History<T>
    {
        #region constructor and declarations
        private Stack<T> items, redoItems;
        private int capacity;
 
        public History()
        {
            setStacks(20);
        }
        public History(int capacity)
        {
            setStacks(capacity);
        } 
        public History(T startItem, int capacity):this(capacity)
        {
            go(startItem, true);
        } 
        private void setStacks(int capacity)
        {
            this.capacity = capacity;
            items = new Stack<T>(capacity);
            redoItems = new Stack<T>(capacity);
        }
        #endregion
 
        #region misc properties and methods
        /// <summary>
        /// Capacity of the history. 
        /// </summary>
        public int Capacity
        {
            get { return capacity; }
        }
        /// <summary>
        /// Number of items in the history.
        /// </summary>
        public int Count
        {
            get { return items.Count + redoItems.Count; }
        }
        /// <summary>
        /// Number of items in the redo history.
        /// </summary>
        public int RedoCount
        {
            get { return redoItems.Count; }
        }
        /// <summary>
        /// Number of items in the undo history.
        /// </summary>
        public int UndoCount
        {
            get { return items.Count; }
        }
        /// <summary>
        /// True if there is more than one item in the history
        /// </summary>
        public bool UndoEnabled
        {
            get { return items.Count>1; }
        }
        /// <summary>
        /// True if there is at least one item in the redo history
        /// </summary>
        public bool RedoEnabled
        {
            get { return redoItems.Count > 0; }
        }
        /// <summary>
        /// Free space in the history.
        /// </summary>
        public int FreeCount
        {
            get { return capacity - items.Count; }
        }
        /// <summary>
        /// Clear the history but keep the first item
        /// </summary>
        public void clear()
        {
            items.Clear();
        }
 
 
	#endregion
 
        #region navigation properties and methods
        /// <summary>
        /// Current item in the navigation history.
        /// Returns default value if no item found
        /// </summary>
        public T Current
        {
            get
            {
                try
                {
                    return items.Peek();
                }
                catch (Exception)
                {
                    return default(T);
                }
            }
        }
        /// <summary>
        /// Add an item in the history.
        /// Reset redo.  
        /// </summary>
        /// <param name="item">Item to put on the history</param>
        /// <param name="toClone">
        /// if ref type and set to true, do not clone the value. 
        /// In this case, be carefull : referenced object is not maintained
        /// 
        /// If val type, this parameter has no effect
        /// </param>
        /// <exception cref="NotSupportedException">Throwed if bypassClone is false, and item is a ref type not clonable</exception>
        public void go(T item, bool bypassClone)
        {
            if (!bypassClone && default(T) == null)
            {
                if (item is ICloneable)
                {
                    item = (T)((ICloneable)item).Clone();
                }
                else
                    throw new NotSupportedException(String.Format("{0} not cloneable",item.ToString()));
            }
            items.Push(item);
            if(redoItems.Count>0)
                redoItems.Clear();
            //System.Console.WriteLine(String.Format("Go : {0}/{1} [{2}]", items.Count, redoItems.Count, item));
        }
        /// <summary>
        /// Add an item in the history.
        /// Reset redo.  
        /// </summary>
        /// <param name="item">Item to put on the history</param>
        /// <exception cref="NotSupportedException">Throwed if item is a ref type not clonable</exception>
        public void go(T item)
        {
            if (default(T) == null)
            {
                if (item is ICloneable)
                {
                    item = (T)((ICloneable)item).Clone();
                }
                else
                    throw new NotSupportedException(String.Format("{0} not cloneable", item.ToString()));
            }
            items.Push(item);
            if (redoItems.Count > 0)
                redoItems.Clear();
            //System.Console.WriteLine(String.Format("Go : {0}/{1} [{2}]", items.Count, redoItems.Count, item));
        }
        /// <summary>
        /// Previous item in the navigation history.
        /// </summary>
        /// <exception cref="System.InvalidOperationException">if no more items exists before current</exception>
        public T Undo
        {
            get
            {
                redoItems.Push(items.Pop());
                //System.Console.WriteLine(String.Format("Undo : {0}/{1}", items.Count, redoItems.Count));
                return items.Peek();
            }
        }
        /// <summary>
        /// Previous item in the navigation history.
        /// Return null (or default value) if no more items exists before current
        /// </summary>
        public T UndoSafe
        {
            get
            {
                try
                {
                    redoItems.Push(items.Pop());
                    return items.Peek();
                }
                catch (Exception)
                {
                    return default(T);
                }
            }
        }
        /// <summary>
        /// Redo item in the navigation history.
        /// </summary>
        /// <exception cref="System.InvalidOperationException">if no more items exists after current</exception>
        public T Redo
        {
            get
            {
                items.Push(redoItems.Pop());
                //System.Console.WriteLine(String.Format("Redo : {0}/{1}", items.Count, redoItems.Count));
                return items.Peek();
            }
        }
        /// <summary>
        /// Redo item in the navigation history.
        /// Return null (or default value) if no more items exists after current
        /// </summary>
        public T RedoSafe
        {
            get
            {
                try
                {
                    items.Push(redoItems.Pop());
                    return items.Peek();
                }
                catch (Exception)
                {
                    return default(T);
                }
            }
        } 
        #endregion
    }
}