Range<T>

using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
using System.Collections;

namespace SAS.Core.CommonObjects
{
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class Range<T> : IEnumerable<T>
        where T : IComparable<T>
    {
        private T m_Min;
        private T m_Max;
        private bool minIsSet;
        private bool maxIsSet;

        public Range() { }
        public Range(T min, T max) {
            m_Min = min;
            m_Max = max;
        }

        public T Min {
            get {
                return m_Min;
            }
            set {
                m_Min = value;
                minIsSet = true;
            }
        }

        public T Max {
            get {
                return m_Max;
            }
            set {
                m_Max = value;
                maxIsSet = true;
            }
        }

        public T Size {
            get {
                return Calculator.Difference(m_Max, m_Min);
            }
        }

        public bool Contains(T p) {
            return p.CompareTo(m_Min) >= 0 && p.CompareTo(m_Max) <= 0;
        }

        public void SetMinAN(T against) {
            if (!minIsSet) {
                Min = against;
            } else {
                m_Min = (against.CompareTo(m_Min) < 0) ? against : m_Min;
            }
        }

        public void SetMaxAN(T against) {
            if (!maxIsSet) {
                Max = against;
            } else {
                m_Max = (against.CompareTo(m_Max) > 0) ? against : m_Max;
            }
        }

        public void SetMinMaxAgainst(T val) {
            SetMinAN(val);
            SetMaxAN(val);
        }

        public void SetMinMaxAgainst(Range<T> range) {
            SetMinAN(range.Min);
            SetMaxAN(range.Max);
        }

        public override string ToString() {
            return "Range [" + m_Min + ", " + m_Max + "]";
        }

        private ICalculator<T> Calculator {
            get {
                return Calculators.GetCalculator<T>();
            }
        }

        public void Add(object o) { }//--for Xml serialization

        IEnumerator IEnumerable.GetEnumerator() {
            return (IEnumerator)new RangeEnumerator<T>(this);
        }

        public IEnumerator<T> GetEnumerator() {
            return (IEnumerator<T>)new RangeEnumerator<T>(this);
        }

        /// <summary>
        /// Gets the value between Min and Max based on a fraction.
        /// </summary>
        /// <param name="frac">a fraction e.g. 0.5 will return the mid-point</param>
        public T GetFraction(T frac) {
            return Calculator.Sum(m_Min, Calculator.Product(frac, Size));
        }
    }

    public class RangeEnumerator<T> : IEnumerator<T>
        where T : IComparable<T>
    {
        private T en_Position;
        Range<T> mRange;
        public RangeEnumerator(Range<T> range) {
            mRange = range;
            Reset();
        }

        public bool MoveNext() {
            if (mRange.Size.CompareTo(en_Position) == 1) {//--i.e. if Size > en_Position
                en_Position = Calculator.Sum(en_Position, Calculator.One);
                return true;
            }
            return false;
        }

        public void Reset() {
            en_Position = Calculator.Difference(Calculator.Zero, Calculator.One);//i.e. -1
        }

        private ICalculator<T> Calculator {
            get {
                return Calculators.GetCalculator<T>();
            }
        }

        public object Current {
            get {
                return Calculator.Sum(en_Position, mRange.Min);
            }
        }

        T IEnumerator<T>.Current {
            get {
                return Calculator.Sum(en_Position, mRange.Min);
            }
        }

        public void Dispose() { }
    }
}