Changeset 4810 for branches/HeuristicLab.Hive/sources/HeuristicLab.Hive/HeuristicLab.Hive.JobBase/3.3/PluginUtil.cs

Timestamp:

11/16/10 14:31:52 (13 years ago)

Author:

cneumuel

Message:

#1260

• changed dependency discovery machanism: now all locally loaded plugins will be dependencies for a job.
• fixed logging of slaveconsole by limiting the maximum log-messages
• minor bug fixes.

File:

• branches/HeuristicLab.Hive/sources/HeuristicLab.Hive/HeuristicLab.Hive.JobBase/3.3/PluginUtil.cs (modified) (5 diffs)

branches/HeuristicLab.Hive/sources/HeuristicLab.Hive/HeuristicLab.Hive.JobBase/3.3/PluginUtil.cs

@@ -24 +24 @@
 using System.Reflection;
 using HeuristicLab.PluginInfrastructure;
+using System.Linq;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Hive.JobBase {
   public static class PluginUtil {
     #region Required Plugin Search
-    
+
     /// <summary>
     /// Returns a list of plugins in which the type itself and all members 
     /// of the type are declared. Objectgraph is searched recursively.
     /// </summary>
-    public static IEnumerable<IPluginDescription> GetDeclaringPlugins(Type type) {
+    public static IEnumerable<IPluginDescription> GetDeclaringPlugins(IDeepCloneable obj) {
+      object clone = obj.Clone();
       HashSet<Type> types = new HashSet<Type>();
-      FindTypes(type, types, "HeuristicLab.");
-      return GetDeclaringPlugins(types);
+      HashSet<object> objects = new HashSet<object>();
+      string namespaceStart = "HeuristicLab.";
+      FindTypesInObject(clone, objects, types, namespaceStart, 10);
+      return GetDeclaringPlugins(types, namespaceStart);
     }
 
@@ -42 +47 @@
     /// Returns the plugins (including dependencies) in which the given types are declared
     /// </summary>
-    public static IEnumerable<IPluginDescription> GetDeclaringPlugins(IEnumerable<Type> types) {
+    public static IEnumerable<IPluginDescription> GetDeclaringPlugins(IEnumerable<Type> types, string namespaceStart) {
       HashSet<IPluginDescription> plugins = new HashSet<IPluginDescription>();
-      foreach (Type t in types) {
+      var hlTypes = types.Where(x => x.Namespace != null && x.Namespace.StartsWith(namespaceStart));
+      foreach (Type t in hlTypes) {
         FindDeclaringPlugins(ApplicationManager.Manager.GetDeclaringPlugin(t), plugins);
       }
@@ -68 +74 @@
     /// </summary>
     /// <param name="type">the type to be searched</param>
-    /// <param name="types">found types will be stored there, needed in order to avoid duplicates</param>
-    /// <param name="namespaceStart">only types from namespaces which start with this will be searched and added</param>
-    public static void FindTypes(Type type, HashSet<Type> types, string namespaceStart) {
-      if (!types.Contains(type) && type.Namespace.StartsWith(namespaceStart)) {
-        types.Add(type);
+    /// <param name="foundTypes">found types will be stored there, needed in order to avoid duplicates</param>
+    public static void FindTypes(Type type, HashSet<Type> foundTypes, string namespaceStart, int nonNamespaceSearchDepth) {
+      if (type.Namespace != null && type.Namespace.StartsWith(namespaceStart)) {
+        nonNamespaceSearchDepth = 10;
+      } else {
+        nonNamespaceSearchDepth--;
+      }
+
+      if (!foundTypes.Contains(type) && nonNamespaceSearchDepth > 0) {
+        foundTypes.Add(type);
+
+        if (type.IsGenericType) {
+          foreach (Type t in type.GetGenericArguments()) {
+            FindTypes(t, foundTypes, namespaceStart, nonNamespaceSearchDepth);
+          }
+        }
 
         // constructors
         foreach (ConstructorInfo info in type.GetConstructors()) {
           foreach (ParameterInfo paramInfo in info.GetParameters()) {
-            FindTypes(paramInfo.ParameterType, types, namespaceStart);
+            FindTypes(paramInfo.ParameterType, foundTypes, namespaceStart, nonNamespaceSearchDepth);
           }
         }
@@ -83 +100 @@
         // interfaces
         foreach (Type t in type.GetInterfaces()) {
-          FindTypes(t, types, namespaceStart);
+          FindTypes(t, foundTypes, namespaceStart, nonNamespaceSearchDepth);
         }
 
         // events
         foreach (EventInfo info in type.GetEvents()) {
-          FindTypes(info.EventHandlerType, types, namespaceStart);
-          FindTypes(info.DeclaringType, types, namespaceStart);
-        }
-
-        // properties
-        foreach (PropertyInfo info in type.GetProperties()) {
-          FindTypes(info.PropertyType, types, namespaceStart);
-        }
-
-        // fields
-        foreach (FieldInfo info in type.GetFields()) {
-          FindTypes(info.FieldType, types, namespaceStart);
+          FindTypes(info.EventHandlerType, foundTypes, namespaceStart, nonNamespaceSearchDepth);
+          FindTypes(info.DeclaringType, foundTypes, namespaceStart, nonNamespaceSearchDepth);
         }
 
@@ -105 +112 @@
         foreach (MethodInfo info in type.GetMethods()) {
           foreach (ParameterInfo paramInfo in info.GetParameters()) {
-            FindTypes(paramInfo.ParameterType, types, namespaceStart);
+            FindTypes(paramInfo.ParameterType, foundTypes, namespaceStart, nonNamespaceSearchDepth);
           }
-          FindTypes(info.ReturnType, types, namespaceStart);
+          FindTypes(info.ReturnType, foundTypes, namespaceStart, nonNamespaceSearchDepth);
+        }
+
+        // base type
+        if (type.BaseType != null) {
+          FindTypes(type.BaseType, foundTypes, namespaceStart, nonNamespaceSearchDepth);
         }
       }
+    }
+
+    public static void FindTypesInObject(object obj, HashSet<object> visitedObjects, HashSet<Type> types, string namespaceStart, int nonNamespaceSearchDepth) {
+      Type type = obj.GetType();
+      FindTypes(type, types, namespaceStart, nonNamespaceSearchDepth);
+
+      if (type.Namespace != null && type.Namespace.StartsWith(namespaceStart)) {
+        nonNamespaceSearchDepth = 10;
+      } else {
+        nonNamespaceSearchDepth--;
+      }
+
+      if (!visitedObjects.Contains(obj) && nonNamespaceSearchDepth > 0) {
+        visitedObjects.Add(obj);
+
+        // fields
+        foreach (FieldInfo info in GetAllFields(type)) {
+          var value = info.GetValue(obj);
+          if (value == null) {
+            FindTypes(info.FieldType, types, namespaceStart, nonNamespaceSearchDepth);
+          } else {
+            FindTypesInObject(value, visitedObjects, types, namespaceStart, nonNamespaceSearchDepth);
+          }
+        }
+      }
+    }
+
+    public static IEnumerable<FieldInfo> GetAllFields(Type t) {
+      BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy;
+      return t.GetFields(flags);
     }
     #endregion