Changeset 2757 for trunk/sources/HeuristicLab.Operators/3.3/ConditionalBranch.cs

Timestamp:

02/08/10 03:43:36 (14 years ago)

Author:

swagner

Message:

Operator architecture refactoring (#95)

• worked on parameters and operators

File:

• trunk/sources/HeuristicLab.Operators/3.3/ConditionalBranch.cs (modified) (1 diff)

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

@@ -23 +23 @@
 using System.Collections.Generic;
 using System.Text;
+using System.Xml;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Operators {
   /// <summary>
-  /// Branch of (one or)two operators whose executions depend on a specific condition.
+  /// A branch of two operators whose executions depend on a condition.
   /// </summary>
-  public class ConditionalBranch : OperatorBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return @"ConditionalBranch expects to have 1 or 2 sub-operators.
-It will return the 1st sub-operator if ""Condition"" is true and the 2nd sub-operator if ""Condition"" equals to false.
-
-In case a 2nd sub-operator does not exist and ""Condition"" would equal to false, Conditional Branch will not return a new operation."; }
+  [Item("ConditionalBranch", "A branch of two operators whose executions depend on a boolean condition.")]
+  [Creatable("Test")]
+  [EmptyStorableClass]
+  public class ConditionalBranch : SingleSuccessorOperator {
+    public LookupParameter<BoolData> ConditionParameter {
+      get { return (LookupParameter<BoolData>)Parameters["Condition"]; }
+    }
+    protected OperatorParameter TrueBranchParameter {
+      get { return (OperatorParameter)Parameters["TrueBranch"]; }
+    }
+    protected OperatorParameter FalseBranchParameter {
+      get { return (OperatorParameter)Parameters["FalseBranch"]; }
+    }
+    public IOperator TrueBranch {
+      get { return TrueBranchParameter.Value; }
+      set { TrueBranchParameter.Value = value; }
+    }
+    public IOperator FalseBranch {
+      get { return FalseBranchParameter.Value; }
+      set { FalseBranchParameter.Value = value; }
     }
 
-    /// <summary>
-    /// Initializes a new instance of <see cref="ConditionalBranch"/> with one variable info 
-    /// (<c>Condition</c>).
-    /// </summary>
     public ConditionalBranch()
       : base() {
-      AddVariableInfo(new VariableInfo("Condition", "A boolean variable that decides the branch", typeof(BoolData), VariableKind.In));
+      Parameters.Add(new LookupParameter<BoolData>("Condition", "A boolean variable which defines which branch is executed."));
+      Parameters.Add(new OperatorParameter("TrueBranch", "The operator which is executed if the condition is true."));
+      Parameters.Add(new OperatorParameter("FalseBranch", "The operator which is executed if the condition is false."));
     }
 
-    /// <summary>
-    /// Applies the operator of branch one under a specific condition on the given 
-    /// <paramref name="scope"/>, or - if existent - operator of branch two if the condition could not
-    /// be fulfilled. 
-    /// </summary>
-    /// <param name="scope">The scope to apply the operators on.</param>
-    /// <returns>A new <see cref="AtomicOperation"/> with either operator 1 or operator 2 applied
-    /// to the given <paramref name="scope"/> or <c>null</c>.</returns>
-    public override IOperation Apply(IScope scope) {
-      BoolData resultData = GetVariableValue<BoolData>("Condition", scope, true);
-      bool result = resultData.Data;
-
-      if ((result) && (SubOperators.Count > 0) && (SubOperators[0] != null))
-        return new AtomicOperation(SubOperators[0], scope);
-      else if ((!result) && (SubOperators.Count > 1) && (SubOperators[1] != null))
-        return new AtomicOperation(SubOperators[1], scope);
-      return null;
+    public override IExecutionContext Apply() {
+      ExecutionContextCollection next = new ExecutionContextCollection(base.Apply());
+      if (ConditionParameter.ActualValue.Value) {
+        if (TrueBranch != null) next.Insert(0, new ExecutionContext(ExecutionContext.Parent, TrueBranch, ExecutionContext.Scope));
+      } else {
+        if (FalseBranch != null) next.Insert(0, new ExecutionContext(ExecutionContext.Parent, FalseBranch, ExecutionContext.Scope));
+      }
+      return next;
     }
   }