Changeset 2740 for trunk/sources/HeuristicLab.Operators/3.3

Timestamp:

02/03/10 04:43:06 (14 years ago)

Author:

swagner

Message:

Operator architecture refactoring (#95)

• worked on parameters and operators

Location:

trunk/sources/HeuristicLab.Operators/3.3

Files:

• CombinedOperator.cs (modified) (2 diffs)
• Counter.cs (modified) (2 diffs)
• EmptyOperator.cs (modified) (1 diff)
• HeuristicLab.Operators-3.3.csproj (modified) (2 diffs)
• MultipleSuccessorsOperator.cs (added)
• Operator.cs (modified) (4 diffs)
• SequentialProcessor.cs (modified) (1 diff)
• SingleSuccessorOperator.cs (moved) (moved from trunk/sources/HeuristicLab.Operators/3.3/StandardOperator.cs) (1 diff)

trunk/sources/HeuristicLab.Operators/3.3/CombinedOperator.cs

@@ -36 +36 @@
   [Item("CombinedOperator", "An operator which contains an operator graph.")]
   [Creatable("Test")]
-  public sealed class CombinedOperator : StandardOperator, IOperator {
+  public sealed class CombinedOperator : SingleSuccessorOperator, IOperator {
     public override Image ItemImage {
       get { return HeuristicLab.Common.Resources.VS2008ImageLibrary.Module; }
@@ -68 +68 @@
     }
 
-    public override ExecutionContextCollection Apply(ExecutionContext context) {
-      ExecutionContextCollection next = base.Apply(context);
+    public override ExecutionContextCollection Apply() {
+      ExecutionContextCollection next = base.Apply();
       if (operatorGraph.InitialOperator != null)
-        next.Insert(0, new ExecutionContext(context, operatorGraph.InitialOperator, context.Scope));
+        next.Insert(0, new ExecutionContext(ExecutionContext, operatorGraph.InitialOperator, ExecutionContext.Scope));
       return next;
     }

trunk/sources/HeuristicLab.Operators/3.3/Counter.cs

@@ -35 +35 @@
   [EmptyStorableClass]
   [Creatable("Test")]
-  public sealed class Counter : StandardOperator {
+  public sealed class Counter : SingleSuccessorOperator {
     public ItemParameter<IntData> Value {
       get { return (ItemParameter<IntData>)Parameters["Value"]; }
@@ -49 +49 @@
     }
 
-    public override ExecutionContextCollection Apply(ExecutionContext context) {
-      IntData value = (IntData)Value.GetValue(context);
-      IntData increment = (IntData)Increment.GetValue(context);
+    public override ExecutionContextCollection Apply() {
+      IntData value = (IntData)Value.Value;
+      IntData increment = (IntData)Increment.Value;
       value.Value += increment.Value;
-      return base.Apply(context);
+      return base.Apply();
     }
   }

trunk/sources/HeuristicLab.Operators/3.3/EmptyOperator.cs

@@ -34 +34 @@
   [Creatable("Test")]
   [EmptyStorableClass]
-  public sealed class EmptyOperator : StandardOperator {
+  public sealed class EmptyOperator : SingleSuccessorOperator {
     public EmptyOperator()
       : base() {

trunk/sources/HeuristicLab.Operators/3.3/HeuristicLab.Operators-3.3.csproj

@@ -86 +86 @@
   <ItemGroup>
     <Compile Include="CombinedOperator.cs" />
+    <Compile Include="MultipleSuccessorsOperator.cs" />
     <Compile Include="Counter.cs" />
     <Compile Include="EmptyOperator.cs">
@@ -94 +95 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="SequentialProcessor.cs" />
-    <Compile Include="StandardOperator.cs" />
+    <Compile Include="SingleSuccessorOperator.cs" />
   </ItemGroup>
   <ItemGroup>

trunk/sources/HeuristicLab.Operators/3.3/Operator.cs

@@ -84 +84 @@
     }
 
+    [Storable]
+    private ExecutionContext executionContext;
+    protected ExecutionContext ExecutionContext {
+      get { return executionContext; }
+    }
+
     /// <summary>
     /// Initializes a new instance of <see cref="OperatorBase"/> setting the breakpoint flag and 
@@ -107 +113 @@
       clone.canceled = canceled;
       clone.breakpoint = breakpoint;
+      clone.executionContext = (ExecutionContext)cloner.Clone(executionContext);
       return clone;
     }
@@ -112 +119 @@
     /// <inheritdoc/>
     public virtual ExecutionContextCollection Execute(ExecutionContext context) {
-      canceled = false;
-      ExecutionContextCollection next = Apply(context);
-      OnExecuted();
-      return next;
+      try {
+        canceled = false;
+        executionContext = context;
+        foreach (IParameter param in Parameters)
+          param.ExecutionContext = context;
+        ExecutionContextCollection next = Apply();
+        OnExecuted();
+        return next;
+      }
+      finally {
+        foreach (IParameter param in Parameters)
+          param.ExecutionContext = null;
+        context = null;
+      }
     }
     /// <inheritdoc/>
@@ -127 +144 @@
     /// <param name="scope">The scope where to execute the operator</param>
     /// <returns><c>null</c>.</returns>
-    public virtual ExecutionContextCollection Apply(ExecutionContext context) {
+    public virtual ExecutionContextCollection Apply() {
       return new ExecutionContextCollection();
     }

trunk/sources/HeuristicLab.Operators/3.3/SequentialProcessor.cs

@@ -36 +36 @@
   [Creatable("Test")]
   [EmptyStorableClass]
-  public sealed class SequentialProcessor : Operator, IOperator {
-    public new ParameterCollection Parameters {
-      get {
-        return base.Parameters;
-      }
-    }
-    IObservableKeyedCollection<string, IParameter> IOperator.Parameters {
-      get { return Parameters; }
-    }
-
+  public sealed class SequentialProcessor : MultipleSuccessorsOperator {
     public SequentialProcessor()
       : base() {
     }
 
-    public override ExecutionContextCollection Apply(ExecutionContext context) {
+    public override ExecutionContextCollection Apply() {
       ExecutionContextCollection next = new ExecutionContextCollection();
-      foreach (IParameter param in Parameters) {
-        IOperatorParameter opParam = param as IOperatorParameter;
-        if (opParam != null) {
-          IOperator op = (IOperator)opParam.GetValue(context);
-          if (op != null) next.Add(new ExecutionContext(context.Parent, op, context.Scope));
-        }
-      }
+      for (int i = 0; i < Successors.Count; i++)
+        next.Add(new ExecutionContext(ExecutionContext.Parent, Successors[i], ExecutionContext.Scope));
       return next;
     }

trunk/sources/HeuristicLab.Operators/3.3/SingleSuccessorOperator.cs

@@ -32 +32 @@
   /// A base class for operators which have only one successor.
   /// </summary>
-  [Item("StandardOperator", "A base class for operators which have only one successor.")]
+  [Item("SingleSuccessorOperator", "A base class for operators which have only one successor.")]
   [Creatable("Test")]
   [EmptyStorableClass]
-  public abstract class StandardOperator : Operator {
-    public OperatorParameter Successor {
+  public abstract class SingleSuccessorOperator : Operator {
+    protected OperatorParameter SuccessorParameter {
       get { return (OperatorParameter)Parameters["Successor"]; }
     }
-
-    public StandardOperator()
-      : base() {
-      Parameters.Add(new OperatorParameter("Successor", "Operator which is executed next"));
+    public IOperator Successor {
+      get { return SuccessorParameter.Value; }
+      set { SuccessorParameter.Value = value; }
     }
 
-    public override ExecutionContextCollection Apply(ExecutionContext context) {
-      IOperator successor = (IOperator)Successor.GetValue(context);
-      if (successor != null)
-        return new ExecutionContextCollection(new ExecutionContext(context.Parent, successor, context.Scope));
+    public SingleSuccessorOperator()
+      : base() {
+      Parameters.Add(new OperatorParameter("Successor", "Operator which is executed next."));
+    }
+
+    public override ExecutionContextCollection Apply() {
+      if (Successor != null)
+        return new ExecutionContextCollection(new ExecutionContext(ExecutionContext.Parent, Successor, ExecutionContext.Scope));
       else
         return new ExecutionContextCollection();