Changeset 420 for trunk

Timestamp:

08/01/08 21:35:35 (16 years ago)

Author:

gkronber

Message:

worked on #211.

• Implemented downloading of linked operators from the database in AgentList (to allow view/edit of the whole operator graph)
• Implemented downloading and patching of linked operators in RunScheduler to prepare the operator-graph for execution (OperatorLink operator can't be executed)

(there is some code duplication because the patching is very similar in AgentList DatabaseOperatorLibrary and RunScheduler. This needs some more work)

Location:

trunk/sources

Files:

• HeuristicLab.CEDMA.Core/AgentList.cs (modified) (3 diffs)
• HeuristicLab.CEDMA.DB.Interfaces/IDatabase.cs (modified) (1 diff)
• HeuristicLab.CEDMA.Server/RunScheduler.cs (modified) (2 diffs)

trunk/sources/HeuristicLab.CEDMA.Core/AgentList.cs

@@ -30 +30 @@
 using System.Runtime.Serialization;
 using System.IO;
+using HeuristicLab.Operators;
 
 namespace HeuristicLab.CEDMA.Core {
@@ -50 +51 @@
         newAgent.Status = a.Status;
         IOperatorGraph opGraph = (IOperatorGraph)PersistenceManager.RestoreFromGZip(a.RawData);
-        foreach(IOperator op in opGraph.Operators) newAgent.OperatorGraph.AddOperator(op);
+
+        DownloadOperators(opGraph, new Dictionary<long, IOperator>());
+
+        foreach(IOperator op in opGraph.Operators) {
+          newAgent.OperatorGraph.AddOperator(op);
+        }
         newAgent.OperatorGraph.InitialOperator = opGraph.InitialOperator;
         agentList.Add(newAgent);
@@ -80 +86 @@
     }
 
+    private void DownloadOperators(IOperatorGraph opGraph, Dictionary<long, IOperator> downloaded) {
+      foreach(IOperator op in opGraph.Operators) {
+        DownloadOperators(op, downloaded);
+      }
+    }
+
+    private void DownloadOperators(IOperator op, Dictionary<long, IOperator> downloaded) {
+      if(op is OperatorLink) {
+        OperatorLink link = op as OperatorLink;
+        if(downloaded.ContainsKey(link.Id)) {
+          link.Operator = downloaded[link.Id];
+        } else {
+          OperatorEntry targetEntry = database.GetOperator(link.Id);
+          IOperator target = (IOperator)PersistenceManager.RestoreFromGZip(targetEntry.RawData);
+          downloaded.Add(link.Id, target);
+          DownloadOperators(target, downloaded);
+          link.Operator = target;
+        }
+      } else if(op is CombinedOperator) {
+        DownloadOperators(((CombinedOperator)op).OperatorGraph, downloaded);
+      }
+    }
+
     public override IView CreateView() {
       return new AgentListView(this);

trunk/sources/HeuristicLab.CEDMA.DB.Interfaces/IDatabase.cs

@@ -73 +73 @@
     ICollection<OperatorEntry> GetOperators();
 
+    [OperationContract]
+    OperatorEntry GetOperator(long agentId);
+
   }
 }

trunk/sources/HeuristicLab.CEDMA.Server/RunScheduler.cs

@@ -76 +76 @@
         IOperatorGraph opGraph = (IOperatorGraph)PersistenceManager.RestoreFromGZip(entry.RawData);
 
-        foreach(IOperator op in opGraph.Operators) {
-          PatchLinks(op);
-        }
+        PatchLinks(opGraph, new Dictionary<long, IOperator>());
 
         AtomicOperation operation = new AtomicOperation(opGraph.InitialOperator, scope);
@@ -99 +97 @@
     }
 
-    private void PatchLinks(IOperator op) {
-      if(op is OperatorLink) {
-        OperatorLink link = op as OperatorLink;
-        OperatorEntry targetEntry = database.GetOperator(link.Id);
-        IOperator target = (IOperator)PersistenceManager.RestoreFromGZip(targetEntry.RawData);
-        ReplaceOperatorInGraph(link, target);
-      } else if(op is CombinedOperator) {
-        CombinedOperator combinedOp = op as CombinedOperator;
-        foreach(IOperator internalOp in combinedOp.OperatorGraph.Operators) {
-          PatchLinks(internalOp);
+    private void PatchLinks(IOperatorGraph opGraph, Dictionary<long, IOperator> patchedOperators) {
+      Dictionary<IOperator, IOperator> patchDictionary = new Dictionary<IOperator, IOperator>();
+      foreach(IOperator op in opGraph.Operators) {
+        IOperator patched = PatchLinks(op, patchedOperators);
+        patchDictionary.Add(op, patched);
+      }
+      foreach(KeyValuePair<IOperator, IOperator> p in patchDictionary) {
+        IOperator original = p.Key;
+        IOperator patch = p.Value;
+        if(original != patch) {
+          foreach(IOperator subOperator in original.SubOperators) {
+            patch.AddSubOperator(subOperator);
+          }
+          if(opGraph.InitialOperator == original)
+            opGraph.InitialOperator = patch;
+          opGraph.RemoveOperator(original.Guid);
+          opGraph.AddOperator(patch);
         }
       }
     }
 
-    private void ReplaceOperatorInGraph(OperatorLink link, IOperator target) {
-      throw new NotImplementedException();
+    private IOperator PatchLinks(IOperator op, Dictionary<long, IOperator> patchedOperators) {
+      if(op is OperatorLink) {
+        OperatorLink link = op as OperatorLink;
+        if(patchedOperators.ContainsKey(link.Id)) {
+          return patchedOperators[link.Id];
+        } else {
+          OperatorEntry targetEntry = database.GetOperator(link.Id);
+          IOperator target = (IOperator)PersistenceManager.RestoreFromGZip(targetEntry.RawData);
+          patchedOperators.Add(link.Id, target);
+          PatchLinks(target, patchedOperators);
+          return target;
+        }
+      } else if(op is CombinedOperator) {
+        PatchLinks(((CombinedOperator)op).OperatorGraph, patchedOperators);
+        return op;
+      }
+      return op;
     }