SmartDate.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="SmartDate.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Provides a date data type that understands the concept</summary>
//-----------------------------------------------------------------------
using System;
using Csla.Properties;
using Csla.Serialization.Mobile;
 
namespace Csla
{
 
  [Serializable()]
#if !NETFX_CORE
  [System.ComponentModel.TypeConverter(typeof(Csla.Core.TypeConverters.SmartDateConverter))]
#endif
  public struct SmartDate : Csla.Core.ISmartField,
#if !NETFX_CORE
    IConvertible, 
#endif
    IComparable, IFormattable, IMobileObject
  {
    private DateTime _date;
    private bool _initialized;
    private EmptyValue _emptyValue;
    private string _format;
    private static string _defaultFormat;
 
#if !NETFX_CORE
    [NonSerialized]
#endif
    [NotUndoable]
    private static Func<string, DateTime?> _customParser;
    
#region EmptyValue enum
 
    public enum EmptyValue
    {
      MinDate,
      MaxDate
    }
 
#endregion
 
#region Constructors
 
    static SmartDate()
    {
      _defaultFormat = "d";
    }
 
    public SmartDate(bool emptyIsMin)
    {
      _emptyValue = GetEmptyValue(emptyIsMin);
      _format = null;
      _initialized = false;
      // provide a dummy value to allow real initialization
      _date = DateTime.MinValue;
      SetEmptyDate(_emptyValue);
    }
 
    public SmartDate(EmptyValue emptyValue)
    {
      _emptyValue = emptyValue;
      _format = null;
      _initialized = false;
      // provide a dummy value to allow real initialization
      _date = DateTime.MinValue;
      SetEmptyDate(_emptyValue);
    }
 
    public SmartDate(DateTime value)
    {
      _emptyValue = Csla.SmartDate.EmptyValue.MinDate;
      _format = null;
      _initialized = false;
      _date = DateTime.MinValue;
      Date = value;
    }
 
    public SmartDate(DateTime value, bool emptyIsMin)
    {
      _emptyValue = GetEmptyValue(emptyIsMin);
      _format = null;
      _initialized = false;
      _date = DateTime.MinValue;
      Date = value;
    }
 
    public SmartDate(DateTime value, EmptyValue emptyValue)
    {
      _emptyValue = emptyValue;
      _format = null;
      _initialized = false;
      _date = DateTime.MinValue;
      Date = value;
    }
 
    public SmartDate(DateTime value, EmptyValue emptyValue, DateTimeKind kind)
    {
      _emptyValue = emptyValue;
      _format = null;
      _initialized = false;
      _date = DateTime.MinValue;
      Date = DateTime.SpecifyKind(value, kind);
    }
 
    public SmartDate(DateTime? value)
    {
      _emptyValue = Csla.SmartDate.EmptyValue.MinDate;
      _format = null;
      _initialized = false;
      _date = DateTime.MinValue;
      if (value.HasValue)
        Date = value.Value;
    }
 
    public SmartDate(DateTime? value, bool emptyIsMin)
    {
      _emptyValue = GetEmptyValue(emptyIsMin);
      _format = null;
      _initialized = false;
      _date = DateTime.MinValue;
      if (value.HasValue)
        Date = value.Value;
    }
 
    public SmartDate(DateTime? value, EmptyValue emptyValue)
    {
      _emptyValue = emptyValue;
      _format = null;
      _initialized = false;
      _date = DateTime.MinValue;
      if (value.HasValue)
        Date = value.Value;
    }
 
    public SmartDate(DateTimeOffset value)
    {
      _emptyValue = Csla.SmartDate.EmptyValue.MinDate;
      _format = null;
      _initialized = false;
      _date = DateTime.MinValue;
      Date = value.DateTime;
    }
 
    public SmartDate(DateTimeOffset value, bool emptyIsMin)
    {
      _emptyValue = GetEmptyValue(emptyIsMin);
      _format = null;
      _initialized = false;
      _date = DateTime.MinValue;
      Date = value.DateTime;
    }
 
    public SmartDate(DateTimeOffset value, EmptyValue emptyValue)
    {
      _emptyValue = emptyValue;
      _format = null;
      _initialized = false;
      _date = DateTime.MinValue;
      Date = value.DateTime;
    }
 
    public SmartDate(string value)
    {
      _emptyValue = EmptyValue.MinDate;
      _format = null;
      _initialized = true;
      _date = DateTime.MinValue;
      this.Text = value;
    }
 
    public SmartDate(string value, bool emptyIsMin)
    {
      _emptyValue = GetEmptyValue(emptyIsMin);
      _format = null;
      _initialized = true;
      _date = DateTime.MinValue;
      this.Text = value;
    }
 
    public SmartDate(string value, EmptyValue emptyValue)
    {
      _emptyValue = emptyValue;
      _format = null;
      _initialized = true;
      _date = DateTime.MinValue;
      this.Text = value;
    }
 
    private static EmptyValue GetEmptyValue(bool emptyIsMin)
    {
      if (emptyIsMin)
        return EmptyValue.MinDate;
      else
        return EmptyValue.MaxDate;
    }
 
    private void SetEmptyDate(EmptyValue emptyValue)
    {
      if (emptyValue == SmartDate.EmptyValue.MinDate)
        this.Date = DateTime.MinValue;
      else
        this.Date = DateTime.MaxValue;
    }
 
#endregion
 
#region Text Support
 
    public static void SetDefaultFormatString(string formatString)
    {
      _defaultFormat = formatString;
    }
 
    public string FormatString
    {
      get
      {
        if (_format == null)
          _format = _defaultFormat;
        return _format;
      }
      set
      {
        _format = value;
      }
    }
 
    public string Text
    {
      get { return DateToString(this.Date, FormatString, _emptyValue); }
      set { this.Date = StringToDate(value, _emptyValue); }
    }
 
#endregion
 
#region Date Support
 
    public DateTime Date
    {
      get
      {
        if (!_initialized)
        {
          _date = _emptyValue == SmartDate.EmptyValue.MinDate ? DateTime.MinValue : DateTime.MaxValue;
          _initialized = true;
        }
        return _date;
      }
      set
      {
        _date = value;
        _initialized = true;
      }
    }
 
    public DateTimeOffset ToDateTimeOffset()
    {
      return new DateTimeOffset(this.Date);
    }
 
    public DateTime? ToNullableDate()
    {
      if (this.IsEmpty)
        return new DateTime?();
      else
        return new DateTime?(this.Date);
    }
 
#endregion
 
#region System.Object overrides
 
    public override string ToString()
    {
      return this.Text;
    }
 
    public string ToString(string format)
    {
      if (string.IsNullOrEmpty(format))
        return this.ToString();
      else
        return DateToString(this.Date, format, _emptyValue);
    }
 
    public override bool Equals(object obj)
    {
      if (obj is SmartDate)
      {
        SmartDate tmp = (SmartDate)obj;
        if (this.IsEmpty && tmp.IsEmpty)
          return true;
        else
          return this.Date.Equals(tmp.Date);
      }
      else if (obj is DateTime)
        return this.Date.Equals((DateTime)obj);
      else if (obj is string)
        return (this.CompareTo(obj.ToString()) == 0);
      else
        return false;
    }
 
    public override int GetHashCode()
    {
      return this.Date.GetHashCode();
    }
 
#endregion
 
#region DBValue
 
#if !NETFX_CORE
    public object DBValue
    {
      get
      {
        if (this.IsEmpty)
          return DBNull.Value;
        else
          return this.Date;
      }
    }
#endif
 
#endregion
 
#region Empty Dates
 
    public bool IsEmpty
    {
      get
      {
        if (_emptyValue == EmptyValue.MinDate)
          return this.Date.Equals(DateTime.MinValue);
        else
          return this.Date.Equals(DateTime.MaxValue);
      }
    }
 
    public bool EmptyIsMin
    {
      get { return (_emptyValue == EmptyValue.MinDate); }
    }
 
#endregion
 
#region Conversion Functions
 
    public static Func<string, DateTime?> CustomParser
    {
      get { return _customParser; }
      set { _customParser = value; }
    }
 
 
    public static SmartDate Parse(string value)
    {
      return new SmartDate(value);
    }
 
    public static SmartDate Parse(string value, EmptyValue emptyValue)
    {
      return new SmartDate(value, emptyValue);
    }
 
    public static SmartDate Parse(string value, bool emptyIsMin)
    {
      return new SmartDate(value, emptyIsMin);
    }
 
    public static bool TryParse(string value, ref SmartDate result)
    {
      return TryParse(value, EmptyValue.MinDate, ref result);
    }
 
    public static bool TryParse(string value, EmptyValue emptyValue, ref SmartDate result)
    {
      System.DateTime dateResult = DateTime.MinValue;
      if (TryStringToDate(value, emptyValue, ref dateResult))
      {
        result = new SmartDate(dateResult, emptyValue);
        return true;
      }
      else
      {
        return false;
      }
    }
 
    public static DateTime StringToDate(string value)
    {
      return StringToDate(value, true);
    }
 
    public static DateTime StringToDate(string value, bool emptyIsMin)
    {
      return StringToDate(value, GetEmptyValue(emptyIsMin));
    }
 
    public static DateTime StringToDate(string value, EmptyValue emptyValue)
    {
      DateTime result = DateTime.MinValue;
      if (TryStringToDate(value, emptyValue, ref result))
        return result;
      else
        throw new ArgumentException(Resources.StringToDateException);
    }
 
    private static bool TryStringToDate(string value, EmptyValue emptyValue, ref DateTime result)
    {
      
      DateTime tmp;
 
      // call custom parser if set...
      if (_customParser != null)
      {
        var tmpValue = _customParser.Invoke(value);
        // i f custom parser returned a value then parsing succeeded
        if (tmpValue.HasValue)
        {
          result = tmpValue.Value;
          return true;
        }
      }
 
      if (String.IsNullOrEmpty(value))
      {
        result = emptyValue == EmptyValue.MinDate ? DateTime.MinValue : DateTime.MaxValue;
        return true;
      }
      if (DateTime.TryParse(value, out tmp))
      {
        result = tmp;
        return true;
      }
      
      string ldate = value.Trim().ToLower();
      if (ldate == Resources.SmartDateT ||
          ldate == Resources.SmartDateToday ||
          ldate == ".")
      {
        result = DateTime.Now;
        return true;
      }
      if (ldate == Resources.SmartDateY ||
          ldate == Resources.SmartDateYesterday ||
          ldate == "-")
      {
        result = DateTime.Now.AddDays(-1);
        return true;
      }
      if (ldate == Resources.SmartDateTom ||
          ldate == Resources.SmartDateTomorrow ||
          ldate == "+")
      {
        result = DateTime.Now.AddDays(1);
        return true;
      }
 
      return false;
    }
 
    public static string DateToString(
      DateTime value, string formatString)
    {
      return DateToString(value, formatString, true);
    }
 
    public static string DateToString(
      DateTime value, string formatString, bool emptyIsMin)
    {
      return DateToString(value, formatString, GetEmptyValue(emptyIsMin));
    }
 
    public static string DateToString(
      DateTime value, string formatString, EmptyValue emptyValue)
    {
      if (emptyValue == EmptyValue.MinDate)
      {
        if (value == DateTime.MinValue)
          return string.Empty;
      }
      else
      {
        if (value == DateTime.MaxValue)
          return string.Empty;
      }
      return string.Format("{0:" + formatString + "}", value);
    }
 
#endregion
 
#region Manipulation Functions
 
    public int CompareTo(SmartDate value)
    {
      if (this.IsEmpty && value.IsEmpty)
        return 0;
      else
        return _date.CompareTo(value.Date);
    }
 
    int IComparable.CompareTo(object value)
    {
      if (value is SmartDate)
        return CompareTo((SmartDate)value);
      else
        throw new ArgumentException(Resources.ValueNotSmartDateException);
    }
 
    public int CompareTo(string value)
    {
      return this.Date.CompareTo(StringToDate(value, _emptyValue));
    }
 
    public int CompareTo(DateTimeOffset value)
    {
      return this.Date.CompareTo(value.DateTime);
    }
 
    public int CompareTo(DateTime value)
    {
      return this.Date.CompareTo(value);
    }
 
    public DateTime Add(TimeSpan value)
    {
      if (IsEmpty)
        return this.Date;
      else
        return this.Date.Add(value);
    }
 
    public DateTime Subtract(TimeSpan value)
    {
      if (IsEmpty)
        return this.Date;
      else
        return this.Date.Subtract(value);
    }
 
    public TimeSpan Subtract(DateTimeOffset value)
    {
      if (IsEmpty)
        return TimeSpan.Zero;
      else
        return this.Date.Subtract(value.DateTime);
    }
 
    public TimeSpan Subtract(DateTime value)
    {
      if (IsEmpty)
        return TimeSpan.Zero;
      else
        return this.Date.Subtract(value);
    }
 
#endregion
 
#region Operators
 
    public static bool operator ==(SmartDate obj1, SmartDate obj2)
    {
      return obj1.Equals(obj2);
    }
 
    public static bool operator !=(SmartDate obj1, SmartDate obj2)
    {
      return !obj1.Equals(obj2);
    }
 
    public static implicit operator string(SmartDate obj1)
    {
      return obj1.Text;
    }
 
    public static implicit operator System.DateTime(SmartDate obj1)
    {
      return obj1.Date;
    }
 
    public static implicit operator System.DateTime?(SmartDate obj1)
    {
      return obj1.ToNullableDate();
    }
 
    public static implicit operator DateTimeOffset(SmartDate obj1)
    {
      return obj1.ToDateTimeOffset();
    }
 
    public static explicit operator SmartDate(string dateValue)
    {
      return new SmartDate(dateValue);
    }
 
    public static implicit operator SmartDate(System.DateTime dateValue)
    {
      return new SmartDate(dateValue);
    }
 
    public static implicit operator SmartDate(System.DateTime? dateValue)
    {
      return new SmartDate(dateValue);
    }
 
    public static explicit operator SmartDate(DateTimeOffset dateValue)
    {
      return new SmartDate(dateValue);
    }
 
    public static bool operator ==(SmartDate obj1, DateTime obj2)
    {
      return obj1.Equals(obj2);
    }
 
    public static bool operator !=(SmartDate obj1, DateTime obj2)
    {
      return !obj1.Equals(obj2);
    }
 
    public static bool operator ==(SmartDate obj1, string obj2)
    {
      return obj1.Equals(obj2);
    }
 
    public static bool operator !=(SmartDate obj1, string obj2)
    {
      return !obj1.Equals(obj2);
    }
 
    public static SmartDate operator +(SmartDate start, TimeSpan span)
    {
      return new SmartDate(start.Add(span), start.EmptyIsMin);
    }
 
    public static SmartDate operator -(SmartDate start, TimeSpan span)
    {
      return new SmartDate(start.Subtract(span), start.EmptyIsMin);
    }
 
    public static TimeSpan operator -(SmartDate start, SmartDate finish)
    {
      return start.Subtract(finish.Date);
    }
 
    public static bool operator >(SmartDate obj1, SmartDate obj2)
    {
      return obj1.CompareTo(obj2) > 0;
    }
 
    public static bool operator <(SmartDate obj1, SmartDate obj2)
    {
      return obj1.CompareTo(obj2) < 0;
    }
 
    public static bool operator >(SmartDate obj1, DateTime obj2)
    {
      return obj1.CompareTo(obj2) > 0;
    }
 
    public static bool operator <(SmartDate obj1, DateTime obj2)
    {
      return obj1.CompareTo(obj2) < 0;
    }
 
    public static bool operator >(SmartDate obj1, string obj2)
    {
      return obj1.CompareTo(obj2) > 0;
    }
 
    public static bool operator <(SmartDate obj1, string obj2)
    {
      return obj1.CompareTo(obj2) < 0;
    }
 
    public static bool operator >=(SmartDate obj1, SmartDate obj2)
    {
      return obj1.CompareTo(obj2) >= 0;
    }
 
    public static bool operator <=(SmartDate obj1, SmartDate obj2)
    {
      return obj1.CompareTo(obj2) <= 0;
    }
 
    public static bool operator >=(SmartDate obj1, DateTime obj2)
    {
      return obj1.CompareTo(obj2) >= 0;
    }
 
    public static bool operator <=(SmartDate obj1, DateTime obj2)
    {
      return obj1.CompareTo(obj2) <= 0;
    }
 
    public static bool operator >=(SmartDate obj1, string obj2)
    {
      return obj1.CompareTo(obj2) >= 0;
    }
 
    public static bool operator <=(SmartDate obj1, string obj2)
    {
      return obj1.CompareTo(obj2) <= 0;
    }
 
#endregion
 
#if !NETFX_CORE
#region  IConvertible
 
    System.TypeCode IConvertible.GetTypeCode()
    {
      return ((IConvertible)_date).GetTypeCode();
    }
 
    bool IConvertible.ToBoolean(System.IFormatProvider provider)
    {
      return ((IConvertible)_date).ToBoolean(provider);
    }
 
    byte IConvertible.ToByte(System.IFormatProvider provider)
    {
      return ((IConvertible)_date).ToByte(provider);
    }
 
    char IConvertible.ToChar(System.IFormatProvider provider)
    {
      return ((IConvertible)_date).ToChar(provider);
    }
 
    System.DateTime IConvertible.ToDateTime(System.IFormatProvider provider)
    {
      return ((IConvertible)_date).ToDateTime(provider);
    }
 
    decimal IConvertible.ToDecimal(System.IFormatProvider provider)
    {
      return ((IConvertible)_date).ToDecimal(provider);
    }
 
    double IConvertible.ToDouble(System.IFormatProvider provider)
    {
      return ((IConvertible)_date).ToDouble(provider);
    }
 
    short IConvertible.ToInt16(System.IFormatProvider provider)
    {
      return ((IConvertible)_date).ToInt16(provider);
    }
 
    int IConvertible.ToInt32(System.IFormatProvider provider)
    {
      return ((IConvertible)_date).ToInt32(provider);
    }
 
    long IConvertible.ToInt64(System.IFormatProvider provider)
    {
      return ((IConvertible)_date).ToInt64(provider);
    }
 
    sbyte IConvertible.ToSByte(System.IFormatProvider provider)
    {
      return ((IConvertible)_date).ToSByte(provider);
    }
 
    float IConvertible.ToSingle(System.IFormatProvider provider)
    {
      return ((IConvertible)_date).ToSingle(provider);
    }
 
    string IConvertible.ToString(System.IFormatProvider provider)
    {
      return ((IConvertible)Text).ToString(provider);
    }
 
    object IConvertible.ToType(System.Type conversionType, System.IFormatProvider provider)
    {
      if (conversionType.Equals(typeof(string)))
        return ((IConvertible)Text).ToType(conversionType, provider);
      else if (conversionType.Equals(typeof(SmartDate)))
        return this;
      else
        return ((IConvertible)_date).ToType(conversionType, provider);
    }
 
    ushort IConvertible.ToUInt16(System.IFormatProvider provider)
    {
      return ((IConvertible)_date).ToUInt16(provider);
    }
 
    uint IConvertible.ToUInt32(System.IFormatProvider provider)
    {
      return ((IConvertible)_date).ToUInt32(provider);
    }
 
    ulong IConvertible.ToUInt64(System.IFormatProvider provider)
    {
      return ((IConvertible)_date).ToUInt64(provider);
    }
 
#endregion
 
#endif
 
#region IFormattable Members
 
    string IFormattable.ToString(string format, IFormatProvider formatProvider)
    {
      return this.ToString(format);
    }
 
#endregion
 
#region IMobileObject Members
 
    void IMobileObject.GetState(SerializationInfo info)
    {
      info.AddValue("SmartDate._date", _date);
      info.AddValue("SmartDate._defaultFormat", _defaultFormat);
      info.AddValue("SmartDate._emptyValue", _emptyValue.ToString());
      info.AddValue("SmartDate._initialized", _initialized);
      info.AddValue("SmartDate._format", _format);
    }
 
    void IMobileObject.SetState(SerializationInfo info)
    {
      _date = info.GetValue<DateTime>("SmartDate._date");
      _defaultFormat = info.GetValue<string>("SmartDate._defaultFormat");
      _emptyValue = (EmptyValue)System.Enum.Parse(typeof(EmptyValue), info.GetValue<string>("SmartDate._emptyValue"), true);
      _format = info.GetValue<string>("SmartDate._format");
      _initialized = info.GetValue<bool>("SmartDate._initialized");
    }
 
    void IMobileObject.SetChildren(SerializationInfo info, MobileFormatter formatter)
    {
      //
    }
 
    void IMobileObject.GetChildren(SerializationInfo info, MobileFormatter formatter)
    {
      //
    }
 
#endregion
  }
}