bad git...

Author: UbitUmarov

CSJ2K/J2kSetup.cs

@@ -0,0 +1,128 @@
+// Copyright (c) 2007-2016 CSJ2K contributors.
+// Licensed under the BSD 3-Clause License.
+
+namespace CSJ2K
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Reflection;
+
+    using CSJ2K.Util;
+
+    /// <summary>
+    /// Setup helper methods for initializing library.
+    /// </summary>
+    internal static class J2kSetup
+    {
+        /// <summary>
+        /// Gets a single instance from the platform assembly implementing the <typeparamref name="T"/> type.
+        /// </summary>
+        /// <typeparam name="T">(Abstract) type for which implementation is requested.</typeparam>
+        /// <returns>The single instance from the platform assembly implementing the <typeparamref name="T"/> type, 
+        /// or null if no or more than one implementations are available.</returns>
+        /// <remarks>It is implicitly assumed that implementation class has a public, parameter-less constructor.</remarks>
+        internal static T GetSinglePlatformInstance<T>()
+        {
+            try
+            {
+                var assembly = GetCurrentAssembly();
+#if NETFX_CORE || NETSTANDARD
+                var type =
+                    assembly.DefinedTypes.Single(
+                        t => (t.IsSubclassOf(typeof(T)) || typeof(T).GetTypeInfo().IsAssignableFrom(t)) && !t.IsAbstract)
+                        .AsType();
+#else
+                var type =
+                    assembly.GetTypes()
+                        .Single(t => (t.IsSubclassOf(typeof(T)) || typeof(T).IsAssignableFrom(t)) && !t.IsAbstract);
+#endif
+                var instance = (T)Activator.CreateInstance(type);
+
+                return instance;
+            }
+            catch (Exception)
+            {
+                return default(T);
+            }
+        }
+
+        /// <summary>
+        /// Gets the default classified instance from the platform assembly implementing the <typeparamref name="T"/> type.
+        /// </summary>
+        /// <typeparam name="T">(Abstract) type for which implementation is requested.</typeparam>
+        /// <returns>The single instance from the platform assembly implementing the <typeparamref name="T"/> type that is classified as default, 
+        /// or null if no or more than one default classified implementations are available.</returns>
+        /// <remarks>It is implicitly assumed that all implementation classes has a public, parameter-less constructor.</remarks>
+        internal static T GetDefaultPlatformInstance<T>() where T : IDefaultable
+        {
+            try
+            {
+                var assembly = GetCurrentAssembly();
+                var types = GetConcreteTypes<T>(assembly);
+
+                return GetDefaultOrSingleInstance<T>(types);
+            }
+            catch (Exception)
+            {
+                return default(T);
+            }
+        }
+
+        private static Assembly GetCurrentAssembly()
+        {
+#if NETFX_CORE || NETSTANDARD
+            return typeof(J2kSetup).GetTypeInfo().Assembly;
+#else
+            return typeof(J2kSetup).Assembly;
+#endif
+        }
+
+        private static IEnumerable<Type> GetConcreteTypes<T>(Assembly assembly)
+        {
+#if NETFX_CORE || NETSTANDARD
+            return assembly.DefinedTypes.Where(
+#else
+            return assembly.GetTypes().Where(
+#endif
+                t =>
+                    {
+                        try
+                        {
+#if NETFX_CORE || NETSTANDARD
+                            return (t.IsSubclassOf(typeof(T)) || typeof(T).GetTypeInfo().IsAssignableFrom(t))
+                                   && !t.IsAbstract;
+#else
+                            return (t.IsSubclassOf(typeof(T)) || typeof(T).IsAssignableFrom(t)) && !t.IsAbstract;
+#endif
+                        }
+                        catch
+                        {
+                            return false;
+                        }
+#if NETFX_CORE || NETSTANDARD
+                    }).Select(t => t.AsType());
+#else
+                    });
+#endif
+        }
+
+        private static T GetDefaultOrSingleInstance<T>(IEnumerable<Type> types) where T : IDefaultable
+        {
+            var instances = types.Select(
+                t =>
+                    {
+                        try
+                        {
+                            return (T)Activator.CreateInstance(t);
+                        }
+                        catch
+                        {
+                            return default(T);
+                        }
+                    }).ToList();
+
+            return instances.Count > 1 ? instances.Single(instance => instance.IsDefault) : instances.SingleOrDefault();
+        }
+    }
+}