AcDuration.cs

Go to the documentation of this file.

using System;

namespace AcUtils
{
    [Serializable]
    public class AcDuration : IFormattable, IEquatable<AcDuration>, IComparable<AcDuration>, IComparable
    {
        private TimeSpan _ts;

        public AcDuration(TimeSpan ts)
        {
            _ts = ts;
        }

        public static implicit operator TimeSpan(AcDuration rhs)
        {
            return (rhs != null) ? rhs._ts : new TimeSpan();
        }

        public static implicit operator AcDuration(TimeSpan rhs)
        {
            return new AcDuration(rhs);
        }

        #region Equality comparison

        public bool Equals(AcDuration other)
        {
            if (ReferenceEquals(other, null)) return false;
            if (ReferenceEquals(this, other)) return true;
            return _ts.Equals(other._ts);
        }

        public override bool Equals(object other)
        {
            if (ReferenceEquals(other, null)) return false;
            if (ReferenceEquals(this, other)) return true;
            if (GetType() != other.GetType()) return false;
            return this.Equals(other as AcDuration);
        }

        public override int GetHashCode()
        {
            return _ts.GetHashCode();
        }
        #endregion

        #region Order comparison

        public int CompareTo(AcDuration other)
        {
            int result;
            if (AcDuration.ReferenceEquals(this, other))
                result = 0;
            else
                result = _ts.CompareTo(other._ts);

            return result;
        }

        int IComparable.CompareTo(object other)
        {
            if (!(other is AcDuration))
                throw new ArgumentException("Argument is not an AcDuration", "other");
            AcDuration o = (AcDuration)other;
            return this.CompareTo(o);
        }
        #endregion

        #region ToString
        public string ToString(string format, IFormatProvider provider)
        {
            if (provider != null)
            {
                ICustomFormatter fmt = provider.GetFormat(this.GetType()) as ICustomFormatter;
                if (fmt != null)
                    return fmt.Format(format, this, provider);
            }

            if (String.IsNullOrEmpty(format))
                format = "G";

            switch (format.ToUpperInvariant())
            {
                case "G": // default when not using a format specifier
                {
                    string hours = $"{_ts.Hours:D2}";
                    string minutes = $"{_ts.Minutes:D2}";
                    string seconds = $"{_ts.Seconds:D2}";
                    string elapsedTime;
                    if (_ts.Days > 0)
                        elapsedTime = $"{_ts.Days} {((_ts.Days == 1) ? "day" : "days")}, {hours}:{minutes}:{seconds}";
                    else
                        elapsedTime = $"{hours}:{minutes}:{seconds}";
                    return elapsedTime;
                }
                case "H":
                    return $"{_ts.Hours:D2}";
                case "M":
                    return $"{_ts.Minutes:D2}";
                case "S":
                    return $"{_ts.Seconds:D2}";
                case "D":
                    return $"{_ts.Days} {((_ts.Days == 1) ? "day" : "days")}";
                default:
                    throw new FormatException($"The {format} format string is not supported.");
            }
        }

        // Calls ToString(string, IFormatProvider) version with a null IFormatProvider argument.
        public string ToString(string format)
        {
            return ToString(format, null);
        }

        // Calls ToString(string, IFormatProvider) version with the general format and a null IFormatProvider argument.
        public override string ToString()
        {
            return ToString("G", null);
        }
        #endregion ToString
    }
}