Merge remote-tracking branch 'origin/dev' into EnumerableYield

CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [3.0.0] - 2018-04-23
+### Added
+ - Adding extension method for getting Informational Version from an Assembly
+ - Adding WeakKeyDictionary for caching
+ - Reflection util methods
+ 
+### Changed
+ - JSON serialization/deserialization features moved into base converter
+ - Removed suffix from assembly name
+ 

CHANGELOG.txt

@@ -1,5 +0,0 @@
-# Changelog
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
-and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).

ICD.Common.Utils.Tests/Collections/WeakKeyDictionaryTest.cs

@@ -0,0 +1,158 @@
+using System;
+using ICD.Common.Utils.Collections;
+using NUnit.Framework;
+
+namespace ICD.Common.Utils.Tests.Collections
+{
+	[TestFixture]
+	public sealed class WeakKeyDictionaryTest
+	{
+		private sealed class TestClass
+		{
+		}
+
+		#region Properties
+
+		[Test]
+		public void CountTest()
+		{
+#if DEBUG
+			Assert.Inconclusive();
+			return;
+#endif
+			WeakKeyDictionary<TestClass, int> dict = new WeakKeyDictionary<TestClass, int>();
+			Assert.AreEqual(0, dict.Count);
+
+			TestClass instance = new TestClass();
+
+			dict.Add(instance, 0);
+
+			Assert.AreEqual(1, dict.Count, "Expected the added item to increase the dictionary size");
+
+			GC.Collect();
+			GC.WaitForPendingFinalizers();
+			GC.Collect();
+
+			Assert.AreEqual(1, dict.Count, "Expected the dictionary to have one uncollected item");
+
+			// Need to actually USE the instance at some point AFTER the collection, otherwise it gets optimized out
+			// and is collected prematurely.
+			// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
+			instance.ToString();
+
+			// Now clear the reference to make sure the instance gets collected.
+			// ReSharper disable once RedundantAssignment
+			instance = null;
+
+			GC.Collect();
+			GC.WaitForPendingFinalizers();
+			GC.Collect();
+
+			Assert.AreEqual(0, dict.Count, "Expected the dictionary to be empty after collecting");
+		}
+
+		[Test]
+		public void KeysTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void ValuesTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void IndexerTest()
+		{
+			Assert.Inconclusive();
+		}
+
+#endregion
+
+#region Methods
+
+		[Test]
+		public void AddTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void ContainsKeyTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void RemoveTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void TryGetValueTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void ClearTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void RemoveCollectedEntries()
+		{
+#if DEBUG
+			Assert.Inconclusive();
+			return;
+#endif
+			WeakKeyDictionary<TestClass, int> dict = new WeakKeyDictionary<TestClass, int>();
+
+			dict.RemoveCollectedEntries();
+			Assert.AreEqual(0, dict.Count, "Expected new dictionary to start empty");
+
+			TestClass instance = new TestClass();
+
+			dict.Add(instance, 0);
+			dict.RemoveCollectedEntries();
+
+			Assert.AreEqual(1, dict.Count, "Expected instance to add to the dictionary count");
+
+			GC.Collect();
+			GC.WaitForPendingFinalizers();
+			GC.Collect();
+
+			dict.RemoveCollectedEntries();
+
+			Assert.AreEqual(1, dict.Count, "Expected instance to remain uncollected and stay in the dictionary");
+
+			// Need to actually USE the instance at some point AFTER the collection, otherwise it gets optimized out
+			// and is collected prematurely.
+			// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
+			instance.ToString();
+
+			// Now clear the reference to make sure the instance gets collected.
+			// ReSharper disable once RedundantAssignment
+			instance = null;
+
+			GC.Collect();
+			GC.WaitForPendingFinalizers();
+			GC.Collect();
+			dict.RemoveCollectedEntries();
+
+			Assert.AreEqual(0, dict.Count, "Expected instance to be collected and removed from the dictionary");
+		}
+
+		[Test]
+		public void GetEnumeratorTest()
+		{
+			Assert.Inconclusive();
+		}
+
+#endregion
+	}
+}

ICD.Common.Utils/AttributeUtils.cs

@@ -84,6 +84,14 @@ namespace ICD.Common.Utils
 			{
 				foreach (Exception inner in e.LoaderExceptions)
 				{
+					if (inner is System.IO.FileNotFoundException)
+					{
+						Logger.AddEntry(eSeverity.Error,
+						                "{0} failed to cache assembly {1} - Could not find one or more dependencies by path",
+						                typeof(AttributeUtils).Name, assembly.GetName().Name);
+						continue;
+					}
+
 					Logger.AddEntry(eSeverity.Error, inner, "{0} failed to cache assembly {1}", typeof(AttributeUtils).Name,
 					                assembly.GetName().Name);
 				}

ICD.Common.Utils/Collections/WeakKeyDictionary.cs

@@ -0,0 +1,273 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using ICD.Common.Properties;
+using ICD.Common.Utils.Extensions;
+
+namespace ICD.Common.Utils.Collections
+{
+	public sealed class WeakKeyReference<T> : WeakReference
+	{
+		private readonly int m_HashCode;
+
+		public new T Target { get { return (T)base.Target; } }
+
+		public int HashCode { get { return m_HashCode; } }
+
+		/// <summary>
+		/// Constructor.
+		/// </summary>
+		/// <param name="key"></param>
+		public WeakKeyReference(T key)
+			: this(key, EqualityComparer<T>.Default)
+		{
+		}
+
+		/// <summary>
+		/// Constructor.
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="comparer"></param>
+		public WeakKeyReference(T key, IEqualityComparer<T> comparer)
+			: base(key)
+		{
+			if (comparer == null)
+				throw new ArgumentNullException("comparer");
+
+			// Retain the object's hash code immediately so that even
+			// if the target is GC'ed we will be able to find and
+			// remove the dead weak reference.
+			m_HashCode = comparer.GetHashCode(key);
+		}
+	}
+
+	public sealed class WeakKeyComparer<T> : IEqualityComparer<WeakKeyReference<T>>
+	{
+		private readonly IEqualityComparer<T> m_Comparer;
+
+		/// <summary>
+		/// Constructor.
+		/// </summary>
+		/// <param name="comparer"></param>
+		public WeakKeyComparer(IEqualityComparer<T> comparer)
+		{
+			if (comparer == null)
+				comparer = EqualityComparer<T>.Default;
+
+			m_Comparer = comparer;
+		}
+
+		public int GetHashCode(WeakKeyReference<T> weakKey)
+		{
+			return weakKey.HashCode;
+		}
+
+		// Note: There are actually 9 cases to handle here.
+		//
+		//  Let Wa = Alive Weak Reference
+		//  Let Wd = Dead Weak Reference
+		//  Let S  = Strong Reference
+		//  
+		//  x  | y  | Equals(x,y)
+		// -------------------------------------------------
+		//  Wa | Wa | comparer.Equals(x.Target, y.Target) 
+		//  Wa | Wd | false
+		//  Wa | S  | comparer.Equals(x.Target, y)
+		//  Wd | Wa | false
+		//  Wd | Wd | x == y
+		//  Wd | S  | false
+		//  S  | Wa | comparer.Equals(x, y.Target)
+		//  S  | Wd | false
+		//  S  | S  | comparer.Equals(x, y)
+		// -------------------------------------------------
+		public bool Equals(WeakKeyReference<T> x, WeakKeyReference<T> y)
+		{
+			bool xIsDead;
+			bool yIsDead;
+
+			T first = GetTarget(x, out xIsDead);
+			T second = GetTarget(y, out yIsDead);
+
+			if (xIsDead)
+				return yIsDead && x == y;
+
+			return !yIsDead && m_Comparer.Equals(first, second);
+		}
+
+		private static T GetTarget(WeakKeyReference<T> obj, out bool isDead)
+		{
+			T target = obj.Target;
+			isDead = !obj.IsAlive;
+			return target;
+		}
+	}
+
+	/// <summary>
+	/// WeakDictionary keeps weak references to keys and drops key/value pairs once the key is garbage collected.
+	/// </summary>
+	/// <typeparam name="TKey"></typeparam>
+	/// <typeparam name="TValue"></typeparam>
+	public sealed class WeakKeyDictionary<TKey, TValue> : IDictionary<TKey, TValue>
+	{
+		private readonly Dictionary<WeakKeyReference<TKey>, TValue> m_Dictionary;
+		private readonly IEqualityComparer<TKey> m_Comparer;
+
+		#region Properties
+
+		public int Count { get { return GetAliveKvps().Count(); } }
+
+		public bool IsReadOnly { get { return false; } }
+
+		public ICollection<TKey> Keys { get { return GetAliveKvps().Select(kvp => kvp.Key).ToArray(); } }
+
+		public ICollection<TValue> Values { get { return GetAliveKvps().Select(kvp => kvp.Value).ToArray(); } }
+
+		public TValue this[TKey key]
+		{
+			get
+			{
+				TValue output;
+				if (TryGetValue(key, out output))
+					return output;
+
+				throw new KeyNotFoundException();
+			}
+			set
+			{
+// ReSharper disable once CompareNonConstrainedGenericWithNull
+				if (key == null)
+					throw new ArgumentNullException("key");
+
+				WeakKeyReference<TKey> weakKey = new WeakKeyReference<TKey>(key, m_Comparer);
+				m_Dictionary[weakKey] = value;
+			}
+		}
+
+		#endregion
+
+		public WeakKeyDictionary()
+			: this(0)
+		{
+		}
+
+		public WeakKeyDictionary(int capacity)
+			: this(capacity, EqualityComparer<TKey>.Default)
+		{
+		}
+
+		public WeakKeyDictionary(IEqualityComparer<TKey> comparer)
+			: this(0, comparer)
+		{
+		}
+
+		public WeakKeyDictionary(int capacity, IEqualityComparer<TKey> comparer)
+		{
+			m_Comparer = comparer;
+
+			WeakKeyComparer<TKey> keyComparer = new WeakKeyComparer<TKey>(m_Comparer);
+			m_Dictionary = new Dictionary<WeakKeyReference<TKey>, TValue>(capacity, keyComparer);
+		}
+
+		#region Methods
+
+		public void Add(TKey key, TValue value)
+		{
+// ReSharper disable once CompareNonConstrainedGenericWithNull
+			if (key == null)
+				throw new ArgumentNullException("key");
+
+			WeakKeyReference<TKey> weakKey = new WeakKeyReference<TKey>(key, m_Comparer);
+			m_Dictionary.Add(weakKey, value);
+		}
+
+		public bool ContainsKey(TKey key)
+		{
+			TValue unused;
+			return TryGetValue(key, out unused);
+		}
+
+		public bool Remove(TKey key)
+		{
+			return m_Dictionary.Remove(new WeakKeyReference<TKey>(key, m_Comparer));
+		}
+
+		public bool TryGetValue(TKey key, out TValue value)
+		{
+			return m_Dictionary.TryGetValue(new WeakKeyReference<TKey>(key, m_Comparer), out value);
+		}
+
+		public void Clear()
+		{
+			m_Dictionary.Clear();
+		}
+
+		/// <summary>
+		/// Removes the left-over weak references for entries in the dictionary
+		/// whose key or value has already been reclaimed by the garbage
+		/// collector. This will reduce the dictionary's Count by the number
+		/// of dead key-value pairs that were eliminated.
+		/// </summary>
+		[PublicAPI]
+		public void RemoveCollectedEntries()
+		{
+			IEnumerable<WeakKeyReference<TKey>> toRemove =
+				m_Dictionary.Select(pair => pair.Key)
+				            .Where(weakKey => !weakKey.IsAlive)
+							.ToArray();
+
+			m_Dictionary.RemoveAll(toRemove);
+		}
+
+		#region ICollection
+
+		void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item)
+		{
+			Add(item.Key, item.Value);
+		}
+
+		bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
+		{
+			return Remove(item.Key);
+		}
+
+		bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item)
+		{
+			return ContainsKey(item.Key);
+		}
+
+		void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
+		{
+			GetAliveKvps().CopyTo(array, arrayIndex);
+		}
+
+		private IEnumerable<KeyValuePair<TKey, TValue>> GetAliveKvps()
+		{
+			foreach (KeyValuePair<WeakKeyReference<TKey>, TValue> kvp in m_Dictionary)
+			{
+				WeakKeyReference<TKey> weakKey = kvp.Key;
+				TKey key = weakKey.Target;
+				if (weakKey.IsAlive)
+					yield return new KeyValuePair<TKey, TValue>(key, kvp.Value);
+			}
+		}
+
+		#endregion
+
+		#region IEnumerator
+
+		public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
+		{
+			return GetAliveKvps().GetEnumerator();
+		}
+
+		IEnumerator IEnumerable.GetEnumerator()
+		{
+			return GetEnumerator();
+		}
+
+		#endregion
+
+		#endregion
+	}
+}

ICD.Common.Utils/EnumUtils.cs

@@ -321,7 +321,7 @@ namespace ICD.Common.Utils
 				throw new ArgumentException(string.Format("{0} is not an enum", value == null ? "NULL" : value.GetType().Name), "value");
 
 			int maxEnumValue = (GetValues<T>().Max(v => (int)(object)v) * 2) -1 ;
-			return Enumerable.Range(1, maxEnumValue).Cast<T>().Where(v => HasFlags(value, v));
+			return Enumerable.Range(1, maxEnumValue).Select(i => (T)(object)i ).Where(v => HasFlags(value, v));
 		}
 
 		/// <summary>

ICD.Common.Utils/EventArguments/GenericEventArgs.cs

@@ -2,8 +2,11 @@
 
 namespace ICD.Common.Utils.EventArguments
 {
-	public class GenericEventArgs<T> : EventArgs
+	public class GenericEventArgs<T> : EventArgs, IGenericEventArgs<T>
 	{
+		/// <summary>
+		/// Gets the wrapped data associated with the event.
+		/// </summary>
 		public T Data { get; private set; }
 
 		/// <summary>

ICD.Common.Utils/EventArguments/IGenericEventArgs.cs

@@ -0,0 +1,10 @@
+namespace ICD.Common.Utils.EventArguments
+{
+	public interface IGenericEventArgs<T>
+	{
+		/// <summary>
+		/// Gets the wrapped data associated with the event.
+		/// </summary>
+		T Data { get; }
+	}
+}

ICD.Common.Utils/Extensions/AssemblyExtensions.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using ICD.Common.Properties;
 using ICD.Common.Utils.IO;
 #if SIMPLSHARP
@@ -12,7 +13,7 @@ namespace ICD.Common.Utils.Extensions
 	public static class AssemblyExtensions
 	{
 		/// <summary>
-		/// Gets the path for the given assembly. Returns null if the assembly can not be found on disk.
+		/// Gets the path for the assembly. Returns null if the assembly can not be found on disk.
 		/// </summary>
 		/// <param name="extends"></param>
 		/// <returns></returns>
@@ -45,10 +46,11 @@ namespace ICD.Common.Utils.Extensions
 		}
 
 		/// <summary>
-		/// Gets the creation date of the given assembly.
+		/// Gets the creation date of the assembly.
 		/// </summary>
 		/// <param name="extends"></param>
 		/// <returns></returns>
+		[PublicAPI]
 		public static DateTime GetCreationTime(this Assembly extends)
 		{
 			if (extends == null)
@@ -57,5 +59,40 @@ namespace ICD.Common.Utils.Extensions
 			string path = extends.GetPath();
 			return path == null ? DateTime.MinValue : IcdFile.GetCreationTime(path);
 		}
+
+		/// <summary>
+		/// Gets the informational version for the assembly.
+		/// </summary>
+		/// <param name="extends"></param>
+		/// <returns></returns>
+		[PublicAPI]
+		public static string GetInformationalVersion(this Assembly extends)
+		{
+			if (extends == null)
+				throw new ArgumentNullException("extends");
+
+			string version;
+			if (extends.TryGetInformationalVersion(out version))
+				return version;
+
+			throw new InvalidOperationException("Assembly has no informational version attribute.");
+		}
+
+		/// <summary>
+		/// Tries to get the informational version for the assembly.
+		/// </summary>
+		/// <param name="extends"></param>
+		/// <param name="version"></param>
+		/// <returns></returns>
+		[PublicAPI]
+		public static bool TryGetInformationalVersion(this Assembly extends, out string version)
+		{
+			if (extends == null)
+				throw new ArgumentNullException("extends");
+
+			return extends.GetCustomAttributes<AssemblyInformationalVersionAttribute>()
+			              .Select(a => a.InformationalVersion)
+			              .TryFirst(out version);
+		}
 	}
 }

ICD.Common.Utils/Extensions/BoolExtensions.cs

@@ -0,0 +1,10 @@
+namespace ICD.Common.Utils.Extensions
+{
+	public static class BoolExtensions
+	{
+		public static ushort ToUShort(this bool b)
+		{
+			return b ? (ushort)1 : (ushort)0;
+		}
+	}
+}

ICD.Common.Utils/Extensions/EnumerableExtensions.cs

@@ -578,6 +578,23 @@ namespace ICD.Common.Utils.Extensions
 			return extends.Where(i => !comparer.Equals(item, i));
 		}
 
+		/// <summary>
+		/// Copies all the elements of the current one-dimensional array to the specified one-dimensional array
+		/// starting at the specified destination array index. The index is specified as a 32-bit integer.
+		/// </summary>
+		/// <typeparam name="T"></typeparam>
+		/// <param name="extends"></param>
+		/// <param name="array"></param>
+		/// <param name="index"></param>
+		public static void CopyTo<T>(this IEnumerable<T> extends, T[] array, int index)
+		{
+			if (extends == null)
+				throw new ArgumentNullException("extends");
+
+			ICollection<T> collection = extends as ICollection<T> ?? extends.ToArray();
+			collection.CopyTo(array, index);
+		}
+
 		/// <summary>
 		/// Returns the sequence as a IcdHashSet.
 		/// </summary>

ICD.Common.Utils/Extensions/EventHandlerExtensions.cs

@@ -28,6 +28,9 @@ namespace ICD.Common.Utils.Extensions
 		public static void Raise<T>(this EventHandler<T> extends, object sender, T args)
 			where T : EventArgs
 		{
+			if (args == null)
+				throw new ArgumentNullException("args");
+
 			if (extends != null)
 				extends(sender, args);
 		}

ICD.Common.Utils/Extensions/JsonExtensions.cs

@@ -75,6 +75,24 @@ namespace ICD.Common.Utils.Extensions
 			return Type.GetType(value);
 		}
 
+		/// <summary>
+		/// Gets the current value as an unsigned integer.
+		/// </summary>
+		/// <param name="extends"></param>
+		/// <returns></returns>
+		[PublicAPI]
+		public static uint GetValueAsUInt(this JsonReader extends)
+		{
+			if (extends == null)
+				throw new ArgumentNullException("extends");
+
+			if (extends.TokenType == JsonToken.Integer)
+				return (uint)(long)extends.Value;
+
+			string message = string.Format("Token {0} {1} is not {2}", extends.TokenType, extends.Value, JsonToken.Integer);
+			throw new InvalidCastException(message);
+		}
+
 		/// <summary>
 		/// Gets the current value as an integer.
 		/// </summary>

ICD.Common.Utils/Extensions/ListExtensions.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using ICD.Common.Properties;
+using ICD.Common.Utils.Comparers;
 
 namespace ICD.Common.Utils.Extensions
 {
@@ -10,6 +11,70 @@ namespace ICD.Common.Utils.Extensions
 	/// </summary>
 	public static class ListExtensions
 	{
+		/// <summary>
+		/// Adds the items into a sorted list.
+		/// </summary>
+		/// <typeparam name="T"></typeparam>
+		/// <param name="extends"></param>
+		/// <param name="items"></param>
+		[PublicAPI]
+		public static void AddSorted<T>(this List<T> extends, IEnumerable<T> items)
+		{
+			if (extends == null)
+				throw new ArgumentNullException("extends");
+
+			if (items == null)
+				throw new ArgumentNullException("items");
+
+			extends.AddSorted(items, Comparer<T>.Default);
+		}
+
+		/// <summary>
+		/// Adds the items into a sorted list.
+		/// </summary>
+		/// <typeparam name="T"></typeparam>
+		/// <param name="extends"></param>
+		/// <param name="items"></param>
+		/// <param name="comparer"></param>
+		[PublicAPI]
+		public static void AddSorted<T>(this List<T> extends, IEnumerable<T> items, IComparer<T> comparer)
+		{
+			if (extends == null)
+				throw new ArgumentNullException("extends");
+
+			if (items == null)
+				throw new ArgumentNullException("items");
+
+			if (comparer == null)
+				throw new ArgumentNullException("comparer");
+
+			items.ForEach(i => extends.AddSorted(i, comparer));
+		}
+
+		/// <summary>
+		/// Adds the items into a sorted list.
+		/// </summary>
+		/// <typeparam name="T"></typeparam>
+		/// <typeparam name="TProp"></typeparam>
+		/// <param name="extends"></param>
+		/// <param name="items"></param>
+		/// <param name="predicate"></param>
+		[PublicAPI]
+		public static void AddSorted<T, TProp>(this List<T> extends, IEnumerable<T> items, Func<T, TProp> predicate)
+		{
+			if (extends == null)
+				throw new ArgumentNullException("extends");
+
+			if (items == null)
+				throw new ArgumentNullException("items");
+
+			if (predicate == null)
+				throw new ArgumentNullException("predicate");
+
+			PredicateComparer<T, TProp> comparer = new PredicateComparer<T, TProp>(predicate);
+			extends.AddSorted(items, comparer);
+		}
+
 		/// <summary>
 		/// Adds the item into a sorted list.
 		/// </summary>
@@ -66,6 +131,27 @@ namespace ICD.Common.Utils.Extensions
 			extends.Insert(index, item);
 		}
 
+		/// <summary>
+		/// Adds the item into a sorted list.
+		/// </summary>
+		/// <typeparam name="T"></typeparam>
+		/// <typeparam name="TProp"></typeparam>
+		/// <param name="extends"></param>
+		/// <param name="item"></param>
+		/// <param name="predicate"></param>
+		[PublicAPI]
+		public static void AddSorted<T, TProp>(this List<T> extends, T item, Func<T, TProp> predicate)
+		{
+			if (extends == null)
+				throw new ArgumentNullException("extends");
+
+			if (predicate == null)
+				throw new ArgumentNullException("predicate");
+
+			PredicateComparer<T, TProp> comparer = new PredicateComparer<T, TProp>(predicate);
+			extends.AddSorted(item, comparer);
+		}
+
 		/// <summary>
 		/// Pads the list to the given total length.
 		/// </summary>

ICD.Common.Utils/Extensions/UshortExtensions.cs

@@ -0,0 +1,10 @@
+namespace ICD.Common.Utils.Extensions
+{
+	public static class UShortExtensions
+	{
+		public static bool ToBool(this ushort u)
+		{
+			return u != 0;
+		}
+	}
+}

ICD.Common.Utils/ICD.Common.Utils_SimplSharp.csproj

@@ -74,6 +74,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Attributes\AbstractIcdAttribute.cs" />
+    <Compile Include="Collections\WeakKeyDictionary.cs" />
     <Compile Include="Comparers\PredicateComparer.cs" />
     <Compile Include="ConsoleColor.cs" />
     <Compile Include="EventArguments\BoolEventArgs.cs" />
@@ -81,14 +82,17 @@
     <Compile Include="EventArguments\DateTimeEventArgs.cs" />
     <Compile Include="EventArguments\FloatEventArgs.cs" />
     <Compile Include="EventArguments\GenericEventArgs.cs" />
+    <Compile Include="EventArguments\IGenericEventArgs.cs" />
     <Compile Include="EventArguments\IntEventArgs.cs" />
     <Compile Include="EventArguments\StringEventArgs.cs" />
     <Compile Include="EventArguments\UShortEventArgs.cs" />
     <Compile Include="EventArguments\XmlRecursionEventArgs.cs" />
     <None Include="ObfuscationSettings.cs" />
+    <Compile Include="Extensions\BoolExtensions.cs" />
     <Compile Include="Extensions\ByteExtensions.cs" />
     <Compile Include="Extensions\ListExtensions.cs" />
     <Compile Include="Comparers\PredicateEqualityComparer.cs" />
+    <Compile Include="Extensions\UshortExtensions.cs" />
     <Compile Include="ProcessorUtils.SimplSharp.cs" />
     <Compile Include="ProcessorUtils.Standard.cs" />
     <Compile Include="ProgramUtils.SimplSharp.cs" />

ICD.Common.Utils/IO/IcdPath.cs

@@ -10,6 +10,10 @@ namespace ICD.Common.Utils.IO
 {
 	public static class IcdPath
 	{
+		public static char DirectorySeparatorChar { get { return Path.DirectorySeparatorChar; } }
+
+		public static char AltDirectorySeparatorChar { get { return Path.AltDirectorySeparatorChar; } }
+
 		public static string GetFileName(string path)
 		{
 			if (path == null)

ICD.Common.Utils/Json/AbstractGenericJsonConverter.cs

@@ -6,6 +6,15 @@ namespace ICD.Common.Utils.Json
 {
 	public abstract class AbstractGenericJsonConverter<T> : JsonConverter
 	{
+		/// <summary>
+		/// Creates a new instance of T.
+		/// </summary>
+		/// <returns></returns>
+		protected virtual T Instantiate()
+		{
+			return ReflectionUtils.CreateInstance<T>();
+		}
+
 		/// <summary>
 		/// Writes the JSON representation of the object.
 		/// </summary>
@@ -36,7 +45,24 @@ namespace ICD.Common.Utils.Json
 		/// <param name="value">The value.</param>
 		/// <param name="serializer">The calling serializer.</param>
 		[PublicAPI]
-		public abstract void WriteJson(JsonWriter writer, T value, JsonSerializer serializer);
+		public virtual void WriteJson(JsonWriter writer, T value, JsonSerializer serializer)
+		{
+			writer.WriteStartObject();
+			{
+				WriteProperties(writer, value, serializer);
+			}
+			writer.WriteEndObject();
+		}
+
+		/// <summary>
+		/// Override to write properties to the writer.
+		/// </summary>
+		/// <param name="writer"></param>
+		/// <param name="value"></param>
+		/// <param name="serializer"></param>
+		protected virtual void WriteProperties(JsonWriter writer, T value, JsonSerializer serializer)
+		{
+		}
 
 		/// <summary>
 		/// Reads the JSON representation of the object.
@@ -70,7 +96,52 @@ namespace ICD.Common.Utils.Json
 		/// The object value.
 		/// </returns>
 		[PublicAPI]
-		public abstract T ReadJson(JsonReader reader, T existingValue, JsonSerializer serializer);
+		public virtual T ReadJson(JsonReader reader, T existingValue, JsonSerializer serializer)
+		{
+			T output = default(T);
+			bool instantiated = false;
+
+			while (reader.Read())
+			{
+				if (reader.TokenType == JsonToken.Null || reader.TokenType == JsonToken.EndObject)
+					break;
+
+				if (!instantiated)
+				{
+					instantiated = true;
+					output = Instantiate();
+				}
+
+				// Get the property
+				if (reader.TokenType != JsonToken.PropertyName)
+					continue;
+				string property = (string)reader.Value;
+
+				// Read into the value
+				reader.Read();
+
+				switch (property)
+				{
+					default:
+						ReadProperty(property, reader, output, serializer);
+						break;
+				}
+			}
+
+			return output;
+		}
+
+		/// <summary>
+		/// Override to handle the current property value with the given name.
+		/// </summary>
+		/// <param name="property"></param>
+		/// <param name="reader"></param>
+		/// <param name="instance"></param>
+		/// <param name="serializer"></param>
+		protected virtual void ReadProperty(string property, JsonReader reader, T instance, JsonSerializer serializer)
+		{
+			reader.Skip();
+		}
 
 		/// <summary>
 		/// Determines whether this instance can convert the specified object type.

ICD.Common.Utils/Json/JsonUtils.cs

@@ -107,9 +107,21 @@ namespace ICD.Common.Utils.Json
 		/// <param name="value"></param>
 		[PublicAPI]
 		public static void Print(object value)
+		{
+			string formatted = Format(value);
+			IcdConsole.PrintLine(formatted);
+		}
+
+		/// <summary>
+		/// Serializes the given item and formats the JSON into a human-readable form.
+		/// </summary>
+		/// <param name="value"></param>
+		/// <returns></returns>
+		[PublicAPI]
+		public static string Format(object value)
 		{
 			string serial = JsonConvert.SerializeObject(value);
-			Print(serial);
+			return Format(serial);
 		}
 
 		/// <summary>

ICD.Common.Utils/PathUtils.cs

@@ -185,6 +185,24 @@ namespace ICD.Common.Utils
 			return IcdFile.Exists(path) || IcdDirectory.Exists(path);
 		}
 
+		/// <summary>
+		/// Returns the path if the given path is already a directory or has a trailing slash.
+		/// Otherwise returns the parent directory name.
+		/// </summary>
+		/// <param name="path"></param>
+		/// <returns></returns>
+		[PublicAPI]
+		public static string GetDirectoryNameFromPath(string path)
+		{
+			if (IcdDirectory.Exists(path))
+				return path;
+
+			if (path.EndsWith(IcdPath.DirectorySeparatorChar) || path.EndsWith(IcdPath.AltDirectorySeparatorChar))
+				return path;
+
+			return IcdPath.GetDirectoryName(path);
+		}
+
 		#endregion
 	}
 }

ICD.Common.Utils/Properties/AssemblyInfo.cs

@@ -4,4 +4,4 @@ using System.Reflection;
 [assembly: AssemblyCompany("ICD Systems")]
 [assembly: AssemblyProduct("ICD.Common.Utils")]
 [assembly: AssemblyCopyright("Copyright © ICD Systems 2018")]
-[assembly: AssemblyVersion("2.0.0.0")]
+[assembly: AssemblyVersion("3.0.0.0")]

ICD.Common.Utils/ReflectionUtils.cs

@@ -195,6 +195,24 @@ namespace ICD.Common.Utils
 			       != null;
 		}
 
+		/// <summary>
+		/// Platform independant delegate instantiation.
+		/// </summary>
+		/// <param name="type"></param>
+		/// <param name="firstArgument"></param>
+		/// <param name="method"></param>
+		/// <returns></returns>
+		public static Delegate CreateDelegate(Type type, object firstArgument, MethodInfo method)
+		{
+			return
+#if SIMPLSHARP
+				CDelegate
+#else
+				Delegate
+#endif
+					.CreateDelegate(type, firstArgument, method);
+		}
+
 		/// <summary>
 		/// Creates an instance of the given type, calling the default constructor.
 		/// </summary>
@@ -368,24 +386,71 @@ namespace ICD.Common.Utils
 				if (type.CanBeNull())
 					return null;
 
-				throw new InvalidCastException();
+				throw new InvalidCastException(string.Format("Unable to convert NULL to type {0}", type.Name));
 			}
 
 			Type valueType = value.GetType();
 			if (valueType.IsAssignableTo(type))
 				return value;
 
-			// Handle enum
-			if (type.IsEnum)
+			try
 			{
-				if (valueType.IsIntegerNumeric())
-					return Enum.ToObject(type, value);
+				// Handle enum
+				if (type.IsEnum)
+				{
+					if (valueType.IsIntegerNumeric())
+						return Enum.ToObject(type, value);
 
-				if (value is string)
-					return Enum.Parse(type, value as string, false);
+					if (value is string)
+						return Enum.Parse(type, value as string, false);
+				}
+
+				return Convert.ChangeType(value, type, null);
 			}
+			catch (Exception e)
+			{
+				string valueString = valueType.ToString();
+				string message = string.Format("Failed to convert {0} to type {1} - {2}", valueString, type, e.Message);
+				throw new InvalidCastException(message, e);
+			}
+		}
 
-			return Convert.ChangeType(value, type, null);
+		/// <summary>
+		/// Subscribes to the event on the given instance using the handler and callback method.
+		/// </summary>
+		/// <param name="instance">The instance with the event. Null for static types.</param>
+		/// <param name="eventInfo">The EventInfo for the event.</param>
+		/// <param name="handler">The instance with the callback MethodInfo. Null for static types.</param>
+		/// <param name="callback">The MethodInfo for the callback method.</param>
+		/// <returns></returns>
+		public static Delegate SubscribeEvent(object instance, EventInfo eventInfo, object handler, MethodInfo callback)
+		{
+			if (eventInfo == null)
+				throw new ArgumentNullException("eventInfo");
+
+			if (callback == null)
+				throw new ArgumentNullException("callback");
+
+			Delegate output = CreateDelegate(eventInfo.EventHandlerType, handler, callback);
+			eventInfo.AddEventHandler(instance, output);
+			return output;
+		}
+
+		/// <summary>
+		/// Unsubscribes from the event on the given instance.
+		/// </summary>
+		/// <param name="instance">The instance with the event. Null for static types.</param>
+		/// <param name="eventInfo">The EventInfo for the event.</param>
+		/// <param name="callback">The Delegate to be removed from the event.</param>
+		public static void UnsubscribeEvent(object instance, EventInfo eventInfo, Delegate callback)
+		{
+			if (eventInfo == null)
+				throw new ArgumentNullException("eventInfo");
+
+			if (callback == null)
+				throw new ArgumentNullException("callback");
+
+			eventInfo.RemoveEventHandler(instance, callback);
 		}
 	}
 }

ICD.Common.Utils/ReprBuilder.cs

@@ -3,6 +3,8 @@ using System.Text;
 
 namespace ICD.Common.Utils
 {
+	public delegate void AddReprPropertyDelegate(string name, object value);
+
 	/// <summary>
 	/// Simple class for building a string representation of an object.
 	/// </summary>

ICD.Common.Utils/StringUtils.cs

@@ -610,5 +610,77 @@ namespace ICD.Common.Utils
 		{
 			return value == null ? null : value.ToUpper();
 		}
+
+		/// <summary>
+		/// Compares the given chars for equality.
+		/// </summary>
+		/// <param name="a"></param>
+		/// <param name="b"></param>
+		/// <param name="ignoreCase"></param>
+		/// <returns></returns>
+		[PublicAPI]
+		public static bool Compare(char a, char b, bool ignoreCase)
+		{
+			if (ignoreCase)
+			{
+				a = char.ToUpper(a, CultureInfo.InvariantCulture);
+				b = char.ToUpper(b, CultureInfo.InvariantCulture);
+			}
+
+			return a == b;
+		}
+
+		/// <summary>
+		/// Find the longest common string between the matches.
+		/// E.g.
+		///
+		/// C:\\Workspace
+		/// C:\\Workshop
+		///
+		/// Results in
+		///
+		/// C:\\Work
+		/// </summary>
+		/// <param name="items"></param>
+		/// <param name="ignoreCase"></param>
+		/// <returns></returns>
+		[PublicAPI]
+		public static string GetLongestCommonIntersectionFromStart(IEnumerable<string> items, bool ignoreCase)
+		{
+			if (items == null)
+				throw new ArgumentNullException("items");
+
+			string output = null;
+
+			foreach (string item in items)
+			{
+				// If there is a null in the sequence that's the best match we can make
+				if (string.IsNullOrEmpty(item))
+					return null;
+
+				// Seed our first item
+				if (output == null)
+				{
+					output = item;
+					continue;
+				}
+
+				// Find the common substring
+				for (int index = 0; index < output.Length; index++)
+				{
+					if (index >= item.Length || !Compare(output[index], item[index], ignoreCase))
+					{
+						output = output.Substring(0, index);
+						break;
+					}
+				}
+
+				// Abandon the search if there is no common substring
+				if (string.IsNullOrEmpty(output))
+					break;
+			}
+
+			return output;
+		}
 	}
 }

ICD.Common.Utils/Timers/IcdStopwatch.cs

@@ -140,6 +140,7 @@ namespace ICD.Common.Utils.Timers
 		{
 			using (IEnumerator<T> enumerator = enumerable.GetEnumerator())
 			{
+// ReSharper disable once AccessToDisposedClosure
 				while (Profile(() => enumerator.MoveNext(), name))
 					yield return enumerator.Current;
 			}