Changeset 5850 for trunk/sources/HeuristicLab.PluginInfrastructure

Timestamp:

03/28/11 19:12:31 (14 years ago)

Author:

mkommend

Message:

#1454: Implemented TypeDiscovery with multiple base types and adapted TypeSelector and CrossValidation.

Location:

trunk/sources/HeuristicLab.PluginInfrastructure/3.3

Files:

• DefaultApplicationManager.cs (modified) (3 diffs)
• Interfaces/IApplicationManager.cs (modified) (2 diffs)
• LightweightApplicationManager.cs (modified) (4 diffs)

trunk/sources/HeuristicLab.PluginInfrastructure/3.3/DefaultApplicationManager.cs

@@ -225 +225 @@
     }
 
+    internal static IEnumerable<Type> GetTypes(IEnumerable<Type> types, bool onlyInstantiable, bool allTypes) {
+      IEnumerable<Type> result = GetTypes(types.First(), onlyInstantiable);
+      foreach (Type type in types.Skip(1)) {
+        IEnumerable<Type> discoveredTypes = GetTypes(type, onlyInstantiable);
+        if (allTypes) result = result.Intersect(discoveredTypes);
+        else result = result.Union(discoveredTypes);
+      }
+
+      if (!allTypes) return result.Distinct();
+      return result;
+    }
+
     /// <summary>
     /// Finds all types that are subtypes or equal to the specified type if they are part of the given
@@ -243 +255 @@
     }
 
+    internal static IEnumerable<Type> GetTypes(IEnumerable<Type> types, IPluginDescription pluginDescription, bool onlyInstantiable, bool allTypes) {
+      IEnumerable<Type> result = GetTypes(types.First(), pluginDescription, onlyInstantiable);
+      foreach (Type type in types.Skip(1)) {
+        IEnumerable<Type> discoveredTypes = GetTypes(type, pluginDescription, onlyInstantiable);
+        if (allTypes) result = result.Intersect(discoveredTypes);
+        else result = result.Union(discoveredTypes);
+      }
+
+      if (!allTypes) return result.Distinct();
+      return result;
+    }
+
     private static bool IsDynamicAssembly(Assembly asm) {
       return (asm is System.Reflection.Emit.AssemblyBuilder) || string.IsNullOrEmpty(asm.Location);
@@ -314 +338 @@
     }
 
-    IEnumerable<Type> IApplicationManager.GetTypes(Type type) {
-      return GetTypes(type, true);
-    }
-
     IEnumerable<Type> IApplicationManager.GetTypes(Type type, bool onlyInstantiable) {
       return GetTypes(type, onlyInstantiable);
     }
-
-    IEnumerable<Type> IApplicationManager.GetTypes(Type type, IPluginDescription plugin) {
-      return GetTypes(type, plugin, true);
+    IEnumerable<Type> IApplicationManager.GetTypes(IEnumerable<Type> types, bool onlyInstantiable, bool allTypes) {
+      return GetTypes(types, onlyInstantiable, allTypes);
     }
 
     IEnumerable<Type> IApplicationManager.GetTypes(Type type, IPluginDescription plugin, bool onlyInstantiable) {
       return GetTypes(type, plugin, onlyInstantiable);
+    }
+    IEnumerable<Type> IApplicationManager.GetTypes(IEnumerable<Type> types, IPluginDescription plugin, bool onlyInstantiable, bool allTypes) {
+      return GetTypes(types, plugin, onlyInstantiable, allTypes);
     }
 

trunk/sources/HeuristicLab.PluginInfrastructure/3.3/Interfaces/IApplicationManager.cs

@@ -56 +56 @@
     /// </summary>
     /// <param name="type">The type to discover.</param>
+    /// <param name="onlyInstantiable">Return only types that are instantiable (instance, abstract... are not returned)</param>
     /// <returns>An enumerable of discovered types.</returns>
-    IEnumerable<Type> GetTypes(Type type);
+    IEnumerable<Type> GetTypes(Type type, bool onlyInstantiable = true);
 
     /// <summary>
-    /// Discovers all types implementing or inheriting <paramref name="type"/> (directly and indirectly).
+    /// Discovers all types implementing or inheriting all or any type in <paramref name="types"/> (directly and indirectly).
     /// </summary>
-    /// <param name="type">The type to discover.</param>
+    /// <param name="types">The types to discover.</param>
     /// <param name="onlyInstantiable">Return only types that are instantiable (instance, abstract... are not returned)</param>
+    /// <param name="allTypes">Specifies if discovered types must implement or inherit all given <paramref name="types"/>.</param>
     /// <returns>An enumerable of discovered types.</returns>
-    IEnumerable<Type> GetTypes(Type type, bool onlyInstantiable);
-
-    /// <summary>
-    /// Discovers all types implementing or inheriting <paramref name="type"/> (directly and indirectly) that are declaed in any assembly of <paramref name="plugin"/>.
-    /// </summary>
-    /// <param name="type">The type to discover.</param>
-    /// <param name="plugin">The declaring plugin.</param>
-    /// <returns>An enumerable of discovered types.</returns>
-    IEnumerable<Type> GetTypes(Type type, IPluginDescription plugin);
+    IEnumerable<Type> GetTypes(IEnumerable<Type> types, bool onlyInstantiable = true, bool allTypes = true);
 
     /// <summary>
@@ -82 +76 @@
     /// <param name="onlyInstantiable">Return only types that are instantiable (instance, abstract... are not returned)</param>
     /// <returns>An enumerable of discovered types.</returns>
-    IEnumerable<Type> GetTypes(Type type, IPluginDescription plugin, bool onlyInstantiable);
+    IEnumerable<Type> GetTypes(Type type, IPluginDescription plugin, bool onlyInstantiable = true);
+
+    /// <summary>
+    /// Discovers all types implementing or inheriting all or any type in <paramref name="types"/> (directly and indirectly) that are declaed in any assembly of <paramref name="plugin"/>.
+    /// </summary>
+    /// <param name="types">The types to discover.</param>
+    /// <param name="plugin">The declaring plugin.</param>
+    /// <param name="onlyInstantiable">Return only types that are instantiable (instance, abstract... are not returned)</param>
+    /// /// <param name="allTypes">Specifies if discovered types must implement or inherit all given <paramref name="types"/>.</param>
+    /// <returns>An enumerable of discovered types.</returns>
+    IEnumerable<Type> GetTypes(IEnumerable<Type> types, IPluginDescription plugin, bool onlyInstantiable = true, bool allTypes = true);
 
     /// <summary>

trunk/sources/HeuristicLab.PluginInfrastructure/3.3/LightweightApplicationManager.cs

@@ -82 +82 @@
     }
 
-
-    /// <summary>
-    /// Finds all instantiable types that are subtypes or equal to the specified type.
-    /// </summary>
-    /// <param name="type">Most general type for which to find matching types.</param>
+    /// <summary>
+    /// Finds all instantiable types that are subtypes or equal to the specified types.
+    /// </summary>
+    /// <param name="types">Most general types for which to find matching types.</param>
     /// <remarks>Return only types that are instantiable 
     /// (interfaces, abstract classes... are not returned)</remarks>
     /// <returns>Enumerable of the discovered types.</returns>
-    public IEnumerable<Type> GetTypes(Type type) {
-      return GetTypes(type, true);
+    public IEnumerable<Type> GetTypes(IEnumerable<Type> types, bool onlyInstantiable = true, bool allTypes = true) {
+      IEnumerable<Type> result = GetTypes(types.First(), onlyInstantiable);
+      foreach (Type type in types.Skip(1)) {
+        IEnumerable<Type> discoveredTypes = GetTypes(type, onlyInstantiable);
+        if (allTypes) result = result.Intersect(discoveredTypes);
+        else result = result.Union(discoveredTypes);
+      }
+
+      if (!allTypes) return result.Distinct();
+      return result;
     }
 
@@ -101 +108 @@
     /// (interfaces, abstract classes... are not returned)</param>
     /// <returns>Enumerable of the discovered types.</returns>
-    public IEnumerable<Type> GetTypes(Type type, bool onlyInstantiable) {
+    public IEnumerable<Type> GetTypes(Type type, bool onlyInstantiable = true) {
       return from asm in AppDomain.CurrentDomain.GetAssemblies()
              from t in GetTypes(type, asm, onlyInstantiable)
@@ -115 +122 @@
     /// (interfaces, abstract classes...  are not returned)</param>
     /// <returns>Enumerable of the discovered types.</returns>
-    private static IEnumerable<Type> GetTypes(Type type, Assembly assembly, bool onlyInstantiable) {
+    private static IEnumerable<Type> GetTypes(Type type, Assembly assembly, bool onlyInstantiable = true) {
       try {
         var assemblyTypes = assembly.GetTypes();
@@ -175 +182 @@
     /// <returns></returns>
     /// <throws>NotSupportedException</throws>
-    public IEnumerable<Type> GetTypes(Type type, IPluginDescription plugin, bool onlyInstantiable) {
+    public IEnumerable<Type> GetTypes(Type type, IPluginDescription plugin, bool onlyInstantiable = true) {
+      throw new NotSupportedException("LightweightApplicationManager doesn't support type discovery for plugins.");
+    }
+
+    /// <summary>
+    /// Not supported by the LightweightApplicationManager
+    /// </summary>
+    /// <param name="type"></param>
+    /// <param name="plugin"></param>
+    /// <param name="onlyInstantiable"></param>
+    /// <returns></returns>
+    /// <throws>NotSupportedException</throws>
+    public IEnumerable<Type> GetTypes(IEnumerable<Type> types, IPluginDescription plugin, bool onlyInstantiable = true, bool allTypes = true) {
       throw new NotSupportedException("LightweightApplicationManager doesn't support type discovery for plugins.");
     }