Added TimeZone related components to Library folder.

Author: codermonkey55

src/Mammatus/Attributes/StringValueAttribute.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+
+namespace Mammatus.Attributes
+{
+    /// <summary>
+    /// Allows you to map a string as metadata to an enum item or property, like:
+    ///
+    /// public enum TimeZoneId {
+    ///		[StringValue("Pacific Standard Time")]
+    ///		PST,
+    ///		. . .
+    ///	}
+    ///
+    /// You can then use StringValueAttribute.Map to get a 2 way dictionary to get these string values out easily.
+    ///
+    /// TODO: Add simpler methods that get just a simple value out one at a time instead of making you build an entire dictionary.
+    /// </summary>
+    public class StringValueAttribute : Attribute
+    {
+        protected string value;
+
+        public StringValueAttribute(string value)
+        {
+            this.value = value;
+        }
+
+        public string Value
+        {
+            get
+            {
+                return value;
+            }
+        }
+
+
+        // TODO: Could be public, but since enum isn't really a type we have no type safety here.
+        protected static string GetStringValue(object enumValue)
+        {
+            var type = enumValue.GetType();
+            var fieldInfo = type.GetField(enumValue.ToString());
+            var stringValueAttributes = (StringValueAttribute[])fieldInfo.GetCustomAttributes(typeof(StringValueAttribute), false);
+            if (stringValueAttributes.Length == 0)
+                throw new ArgumentException("Enum value " + type.Name + "." + enumValue.ToString() + " does not have StringValueAttribute applied.");
+
+            return stringValueAttributes[0].value;
+        }
+
+        /// <summary>
+        /// Call this to map custom strings to enum values and back
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="enumToString">An empty Dictionary to be filled with a map of enum values to the string value in the attribute applied to them</param>
+        /// <param name="stringToEnum">An empty dictionary to be filled with a map of attribute string values to their enum values</param>
+        public static void Map<T>(Dictionary<T, string> enumToString, Dictionary<string, T> stringToEnum)
+        {
+            Type enumType = typeof(T);
+            if (!enumType.IsEnum)
+                throw new Exception("Type must be Enum.");
+
+            var enumValues = (T[])Enum.GetValues(enumType);
+            foreach (var enumVal in enumValues)
+            {
+                string stringVal = GetStringValue(enumVal);
+                enumToString.Add(enumVal, stringVal);
+                stringToEnum.Add(stringVal, enumVal);
+            }
+        }
+    }
+}

src/Mammatus/Library/TimeZone/DateTimeAndZone.cs

@@ -0,0 +1,194 @@
+using System;
+
+namespace Mammatus.Library.TimeZone
+{
+    /// <summary>
+    /// A DateTime object in UTC, and a TimeZoneInfo object representing what timezone it's meant to target.
+    /// </summary>
+    public class DateTimeAndZone
+    {
+        /// <summary>
+        /// The time stored, represented in UTC.
+        /// </summary>
+        public DateTime Utc { get; set; }
+
+        /// <summary>
+        /// The timezone this time originated from.
+        /// </summary>
+        public TimeZoneInfo TimeZone { get; set; }
+
+
+        protected DateTimeAndZone(DateTime utc, TimeZoneInfo timeZone)
+        {
+            if (utc.Kind == DateTimeKind.Local)
+                throw new ArgumentException("DateTime utc must be .Kind == DateTimeKind.Utc, not Local.", "utc");
+
+            Utc = utc;
+            TimeZone = timeZone;
+        }
+
+        public static DateTimeAndZone FromUtc(DateTime utc, TimeZoneInfo timeZone)
+        {
+            if (utc.Kind == DateTimeKind.Local)
+                throw new ArgumentException("DateTime utc must be .Kind == DateTimeKind.Utc, not Local.", "utc");
+
+            return new DateTimeAndZone(utc, timeZone);
+        }
+        public static DateTimeAndZone FromUtcAndTimeZoneId(DateTime utc, TimeZoneId timeZoneId)
+        {
+            if (utc.Kind == DateTimeKind.Local)
+                throw new ArgumentException("DateTime utc must be .Kind == DateTimeKind.Utc, not Local.", "utc");
+
+            return FromUtc(utc, TimeZoneIdMap.Current.FindSystemTimeZoneById(timeZoneId));
+        }
+
+        /// <summary>
+        /// Returns a DateTimeAndZone no matter what. If timezoneShortname is null or not a real timezone,
+        /// it returns UTC
+        /// </summary>
+        /// <param name="utc"></param>
+        /// <param name="timezoneShortname"></param>
+        /// <returns></returns>
+        public static DateTimeAndZone FromUtcAndShort(DateTime utc, string timezoneShortname)
+        {
+            if (utc.Kind == DateTimeKind.Local)
+                throw new ArgumentException("DateTime utc must be .Kind == DateTimeKind.Utc, not Local.", "utc");
+
+            if (timezoneShortname == null)
+                return new DateTimeAndZone(utc, TimeZoneInfo.Utc);
+
+            var tz = TimeZoneShortNameMap.Current.TimeZoneForShortName(timezoneShortname);
+
+            if (tz == null)
+                return new DateTimeAndZone(utc, TimeZoneInfo.Utc);
+
+            return FromUtc(utc, tz);
+        }
+
+        /// <summary>
+        /// Throws an exception if timezone is bad.
+        /// </summary>
+        /// <param name="utc"></param>
+        /// <param name="timezoneShortname"></param>
+        /// <returns></returns>
+        public static DateTimeAndZone FromUtcAndShortStrict(DateTime utc, string timezoneShortname)
+        {
+            if (utc.Kind == DateTimeKind.Local)
+                throw new ArgumentException("DateTime utc must be .Kind == DateTimeKind.Utc, not Local.", "utc");
+
+            if (timezoneShortname == null)
+                throw new ArgumentNullException("timezoneShortname");
+
+            var tz = TimeZoneShortNameMap.Current.TimeZoneForShortName(timezoneShortname);
+
+            if (tz == null)
+                throw new ArgumentOutOfRangeException("timezoneShortname", timezoneShortname + " is not a mapped timezone.");
+
+            return FromUtc(utc, tz);
+        }
+
+        public static DateTimeAndZone FromLocal(DateTime local, TimeZoneInfo timeZone)
+        {
+            if (local.Kind == DateTimeKind.Utc)
+                throw new ArgumentException("DateTime utc must be .Kind == DateTimeKind.Unspecified, not Utc.", "local");
+
+            // We need to push this date from Local (default for Parse) to Unspecified because it's outside
+            // the limited timezone space the DateTime structure understands (Local, UTC, and go fish)
+            if (local.Kind == DateTimeKind.Local)
+                local = DateTime.SpecifyKind(local, DateTimeKind.Unspecified);
+
+            var u = new DateTimeAndZone(TimeZoneInfo.ConvertTimeToUtc(local, timeZone), timeZone);
+            return u;
+        }
+        public static DateTimeAndZone FromLocalAndTimeZoneId(DateTime local, TimeZoneId timeZoneId)
+        {
+            if (local.Kind == DateTimeKind.Utc)
+                throw new ArgumentException("DateTime utc must be .Kind == DateTimeKind.Local, not Utc.", "local");
+
+            return FromLocal(local, TimeZoneIdMap.Current.FindSystemTimeZoneById(timeZoneId));
+        }
+        public static DateTimeAndZone FromLocalAndShort(DateTime local, string timezoneShortname)
+        {
+            if (local.Kind == DateTimeKind.Utc)
+                throw new ArgumentException("DateTime utc must be .Kind == DateTimeKind.Local, not Utc.", "local");
+
+            return FromLocal(local, TimeZoneShortNameMap.Current.TimeZoneForShortName(timezoneShortname));
+        }
+
+
+
+        /// <summary>
+        /// Gets a DateTime object mapped to the current timezone.
+        /// </summary>
+        public DateTime Local
+        {
+            get
+            {
+                var local = TimeZoneInfo.ConvertTimeFromUtc(Utc, this.TimeZone);
+                return local;
+            }
+        }
+
+        /// <summary>
+        /// Whether this timezone is in daylight savings according to the TimeZoneInfo data.
+        ///
+        /// Note that weirdness with the TimeZoneInfo object means this will sometimes return true for timezones that have
+        /// no Daylight Savings rules; if you're trying to determine if a timezone has a DST version, it may be simpler to
+        /// check whether it has a DST shortname mapped.
+        /// </summary>
+        public bool IsDaylightSavings
+        {
+            get
+            {
+                return this.TimeZone.IsDaylightSavingTime(Utc);
+            }
+        }
+
+        /// <summary>
+        /// The short name for the timezone this date/timezone corresponds to, like PST, PDT, HKT.
+        /// </summary>
+        public string TimeZoneShortName
+        {
+            get
+            {
+                return TimeZoneShortNameMap.Current.ShortNameForTime(Utc, TimeZone);
+            }
+        }
+
+
+
+        /// <summary>
+        /// Switches this object to another timezone.
+        /// </summary>
+        /// <param name="shortTz"></param>
+        public void SwitchTimeZone(string shortTz)
+        {
+            SwitchTimeZone(TimeZoneShortNameMap.Current.TimeZoneForShortName(shortTz));
+        }
+        public void SwitchTimeZone(TimeZoneId timeZoneId)
+        {
+            SwitchTimeZone(TimeZoneIdMap.Current.FindSystemTimeZoneById(timeZoneId));
+        }
+        public void SwitchTimeZone(TimeZoneInfo timeZoneInfo)
+        {
+            TimeZone = timeZoneInfo;
+        }
+
+        /// <summary>
+        /// Gets a DateTime object for this time in the requested timezone.
+        /// </summary>
+        /// <param name="shortTz"></param>
+        public DateTime ToLocal(string shortTz)
+        {
+            return ToLocal(TimeZoneShortNameMap.Current.TimeZoneForShortName(shortTz));
+        }
+        public DateTime ToLocal(TimeZoneId timeZoneId)
+        {
+            return ToLocal(TimeZoneIdMap.Current.FindSystemTimeZoneById(timeZoneId));
+        }
+        public DateTime ToLocal(TimeZoneInfo timeZoneInfo)
+        {
+            return TimeZoneInfo.ConvertTimeFromUtc(Utc, timeZoneInfo);
+        }
+    }
+}

src/Mammatus/Library/TimeZone/DateTimeHelper.cs

@@ -0,0 +1,41 @@
+using System;
+
+namespace Mammatus.Library.TimeZone
+{
+    public class DateTimeHelper
+    {
+        /// <summary>
+        /// Parse the date using the Invariant (system) culture.
+        /// 
+        /// Since you're specifying a mask, the culture should be irrelevant.
+        /// 
+        /// Throws an exception if the parse isn't exact.
+        /// </summary>
+        /// <param name="s">Date string to parse</param>
+        /// <param name="mask">Mask to use</param>
+        /// <returns>DateTime parsed</returns>
+        public static DateTime ParseExact(string s, string mask)
+        {
+            return DateTime.ParseExact(s, mask, System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.AssumeUniversal);
+        }
+
+        /// <summary>
+        /// Returns the time between 2 dates formatted as h:mm:ss
+        /// </summary>
+        public static string ElapsedHMS(DateTime start, DateTime end)
+        {
+            var t = end - start;
+            // Weirdo format required http://stackoverflow.com/questions/12543349/timespan-tostring-d-hhmm
+            return t.ToString("h':'mm':'ss");
+        }
+
+        /// <summary>
+        /// Returns the time between 2 dates formatted as s.x (1 decimal place of partial seconds)
+        /// </summary>
+        public static string ElapsedSm(DateTime start, DateTime end)
+        {
+            var t = end - start;
+            return t.TotalSeconds.ToString("0.0");
+        }
+    }
+}