Changeset 5850

Timestamp:

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

Author:

mkommend

Message:

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

Location:

trunk/sources

Files:

• HeuristicLab.Algorithms.DataAnalysis.Views/3.4/CrossValidationView.cs (modified) (3 diffs)
• HeuristicLab.Core.Views/3.3/TypeSelector.cs (modified) (4 diffs)
• HeuristicLab.PluginInfrastructure/3.3/DefaultApplicationManager.cs (modified) (3 diffs)
• HeuristicLab.PluginInfrastructure/3.3/Interfaces/IApplicationManager.cs (modified) (2 diffs)
• HeuristicLab.PluginInfrastructure/3.3/LightweightApplicationManager.cs (modified) (4 diffs)

trunk/sources/HeuristicLab.Algorithms.DataAnalysis.Views/3.4/CrossValidationView.cs

@@ -21 +21 @@
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Windows.Forms;
@@ -252 +253 @@
             if (error != null) throw error;
             IAlgorithm algorithm = content as IAlgorithm;
-            if (algorithm == null || !(algorithm.Problem is IDataAnalysisProblem<IDataAnalysisProblemData>))
+            if (algorithm == null || !(algorithm.Problem is IDataAnalysisProblem))
               MessageBox.Show(this, "The selected file does not contain an algorithm or the problem of the algorithm is not a DataAnalysisProblem.", "Invalid File", MessageBoxButtons.OK, MessageBoxIcon.Error);
             else
@@ -274 +275 @@
         problemTypeSelectorDialog.Caption = "Select Problem";
         problemTypeSelectorDialog.TypeSelector.Caption = "Available Problems";
-        problemTypeSelectorDialog.TypeSelector.Configure(Content.ProblemType, false, true);
-      }
+      }
+      problemTypeSelectorDialog.TypeSelector.Configure(new List<Type>() { Content.ProblemType, Content.Algorithm.ProblemType }, false, true);
       if (problemTypeSelectorDialog.ShowDialog(this) == DialogResult.OK) {
-        try {
-          Content.Problem = (IDataAnalysisProblem)problemTypeSelectorDialog.TypeSelector.CreateInstanceOfSelectedType();
-        }
-        catch (Exception ex) {
-          ErrorHandling.ShowErrorDialog(this, ex);
-        }
+        Content.Problem = (IDataAnalysisProblem)problemTypeSelectorDialog.TypeSelector.CreateInstanceOfSelectedType();
       }
     }

trunk/sources/HeuristicLab.Core.Views/3.3/TypeSelector.cs

@@ -35 +35 @@
     protected TypeSelectorDialog typeSelectorDialog;
 
-    protected Type baseType;
-    public Type BaseType {
-      get { return baseType; }
+    protected IEnumerable<Type> baseTypes;
+    public IEnumerable<Type> BaseTypes {
+      get { return baseTypes; }
     }
     protected bool showNotInstantiableTypes;
@@ -86 +86 @@
 
     public virtual void Configure(Type baseType, bool showNotInstantiableTypes, bool showGenericTypes) {
-      if (baseType == null) throw new ArgumentNullException();
+      Configure(new List<Type>() { baseType }, showNotInstantiableTypes, showGenericTypes);
+    }
+
+    public virtual void Configure(IEnumerable<Type> baseTypes, bool showNotInstantiableTypes, bool showGenericTypes) {
+      if (baseTypes == null) throw new ArgumentNullException();
       if (InvokeRequired)
-        Invoke(new Action<Type, bool, bool>(Configure), baseType, showNotInstantiableTypes, showGenericTypes);
+        Invoke(new Action<IEnumerable<Type>, bool, bool>(Configure), baseTypes, showNotInstantiableTypes, showGenericTypes);
       else {
-        this.baseType = baseType;
+        this.baseTypes = baseTypes;
         this.showNotInstantiableTypes = showNotInstantiableTypes;
         this.showGenericTypes = showGenericTypes;
@@ -115 +119 @@
           pluginNode.Tag = plugin;
 
-          var types = from t in ApplicationManager.Manager.GetTypes(BaseType, plugin, ShowNotInstantiableTypes)
+          var types = from t in ApplicationManager.Manager.GetTypes(BaseTypes, plugin, ShowNotInstantiableTypes)
                       orderby t.Name ascending
                       select t;
@@ -252 +256 @@
       }
       Type param = typeParametersListView.SelectedItems[0].Tag as Type;
-      Type[] contraints = param.GetGenericParameterConstraints();
+      Type[] constraints = param.GetGenericParameterConstraints();
       bool showNotInstantiableTypes = !param.GenericParameterAttributes.HasFlag(GenericParameterAttributes.DefaultConstructorConstraint);
-      typeSelectorDialog.TypeSelector.Configure(typeof(IItem), showNotInstantiableTypes, true);
+      typeSelectorDialog.TypeSelector.Configure(constraints, showNotInstantiableTypes, true);
 
       if (typeSelectorDialog.ShowDialog(this) == DialogResult.OK) {

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.");
     }