Changeset 12132 for stable

Timestamp:

03/05/15 09:46:33 (10 years ago)

Author:

ascheibe

Message:

#2342 merged r12072 into stable

Location:

stable

Files:

• . (modified) (1 prop)
• HeuristicLab.Operators/3.3/DataReducer.cs (modified) (15 diffs)

stable/HeuristicLab.Operators/3.3/DataReducer.cs

@@ -40 +40 @@
       get { return (LookupParameter<IItem>)Parameters["TargetParameter"]; }
     }
-    public ValueParameter<ReductionOperation> ReductionOperation {
-      get { return (ValueParameter<ReductionOperation>)Parameters["ReductionOperation"]; }
-    }
-    public ValueParameter<ReductionOperation> TargetOperation {
-      get { return (ValueParameter<ReductionOperation>)Parameters["TargetOperation"]; }
+    public ValueLookupParameter<ReductionOperation> ReductionOperation {
+      get { return (ValueLookupParameter<ReductionOperation>)Parameters["ReductionOperation"]; }
+    }
+    public ValueLookupParameter<ReductionOperation> TargetOperation {
+      get { return (ValueLookupParameter<ReductionOperation>)Parameters["TargetOperation"]; }
     }
     #endregion
@@ -58 +58 @@
       Parameters.Add(new ScopeTreeLookupParameter<IItem>("ParameterToReduce", "The parameter on which the reduction operation should be applied."));
       Parameters.Add(new LookupParameter<IItem>("TargetParameter", "The target variable in which the reduced value should be stored."));
-      Parameters.Add(new ValueParameter<ReductionOperation>("ReductionOperation", "The operation which is applied on the parameters to reduce."));
-      Parameters.Add(new ValueParameter<ReductionOperation>("TargetOperation", "The operation used to apply the reduced value to the target variable."));
+      Parameters.Add(new ValueLookupParameter<ReductionOperation>("ReductionOperation", "The operation which is applied on the parameters to reduce.", new ReductionOperation()));
+      Parameters.Add(new ValueLookupParameter<ReductionOperation>("TargetOperation", "The operation used to apply the reduced value to the target variable.", new ReductionOperation()));
       #endregion
     }
@@ -65 +65 @@
     public override IDeepCloneable Clone(Cloner cloner) {
       return new DataReducer(this, cloner);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      // BackwardsCompatibility3.3
+      var oldReductionOperation = Parameters["ReductionOperation"] as ValueParameter<ReductionOperation>;
+      if (oldReductionOperation != null) {
+        Parameters.Remove("ReductionOperation");
+        Parameters.Add(new ValueLookupParameter<ReductionOperation>("ReductionOperation", "The operation which is applied on the parameters to reduce.", oldReductionOperation.Value));
+      }
+      var oldTargetOperation = Parameters["TargetOperation"] as ValueParameter<ReductionOperation>;
+      if (oldTargetOperation != null) {
+        Parameters.Remove("TargetOperation");
+        Parameters.Add(new ValueLookupParameter<ReductionOperation>("TargetOperation", "The operation used to apply the reduced value to the target variable.", oldTargetOperation.Value));
+      }
     }
 
@@ -89 +104 @@
     private void CalculateResult(IEnumerable<int> values, Type targetType) {
       int result;
-      switch (ReductionOperation.Value.Value) {
+      switch (ReductionOperation.ActualValue.Value) {
         case ReductionOperations.Sum:
           result = values.Sum();
@@ -112 +127 @@
           break;
         default:
-          throw new InvalidOperationException(string.Format("Operation {0} is not supported as ReductionOperation for type: {1}.", ReductionOperation.Value.Value, targetType));
+          throw new InvalidOperationException(string.Format("Operation {0} is not supported as ReductionOperation for type: {1}.", ReductionOperation.ActualValue.Value, targetType));
       }
 
       IntValue target;
-      switch (TargetOperation.Value.Value) {
+      switch (TargetOperation.ActualValue.Value) {
         case ReductionOperations.Sum:
           target = InitializeTarget<IntValue, int>(targetType, 0);
@@ -142 +157 @@
           break;
         default:
-          throw new InvalidOperationException(string.Format("Operation {0} is not supported as TargetOperation for type: {1}.", TargetOperation.Value.Value, targetType));
+          throw new InvalidOperationException(string.Format("Operation {0} is not supported as TargetOperation for type: {1}.", TargetOperation.ActualValue.Value, targetType));
       }
     }
@@ -149 +164 @@
     private void CalculateResult(IEnumerable<double> values, Type targetType) {
       double result;
-      switch (ReductionOperation.Value.Value) {
+      switch (ReductionOperation.ActualValue.Value) {
         case ReductionOperations.Sum:
           result = values.Sum();
@@ -172 +187 @@
           break;
         default:
-          throw new InvalidOperationException(string.Format("Operation {0} is not supported as ReductionOperation for type: {1}.", ReductionOperation.Value.Value, targetType));
+          throw new InvalidOperationException(string.Format("Operation {0} is not supported as ReductionOperation for type: {1}.", ReductionOperation.ActualValue.Value, targetType));
       }
 
       DoubleValue target;
-      switch (TargetOperation.Value.Value) {
+      switch (TargetOperation.ActualValue.Value) {
         case ReductionOperations.Sum:
           target = InitializeTarget<DoubleValue, double>(targetType, 0.0);
@@ -202 +217 @@
           break;
         default:
-          throw new InvalidOperationException(string.Format("Operation {0} is not supported as TargetOperation for type: {1}.", TargetOperation.Value.Value, targetType));
+          throw new InvalidOperationException(string.Format("Operation {0} is not supported as TargetOperation for type: {1}.", TargetOperation.ActualValue.Value, targetType));
       }
     }
@@ -209 +224 @@
     private void CalculateResult(IEnumerable<TimeSpan> values, Type targetType) {
       TimeSpan result;
-      switch (ReductionOperation.Value.Value) {
+      switch (ReductionOperation.ActualValue.Value) {
         case ReductionOperations.Sum:
           result = values.Aggregate(new TimeSpan(), (x, y) => x + y);
@@ -226 +241 @@
           break;
         default:
-          throw new InvalidOperationException(string.Format("Operation {0} is not supported as ReductionOperation for type: {1}.", ReductionOperation.Value.Value, targetType));
+          throw new InvalidOperationException(string.Format("Operation {0} is not supported as ReductionOperation for type: {1}.", ReductionOperation.ActualValue.Value, targetType));
       }
 
       TimeSpanValue target;
-      switch (TargetOperation.Value.Value) {
+      switch (TargetOperation.ActualValue.Value) {
         case ReductionOperations.Sum:
           target = InitializeTarget<TimeSpanValue, TimeSpan>(targetType, new TimeSpan());
@@ -252 +267 @@
           break;
         default:
-          throw new InvalidOperationException(string.Format("Operation {0} is not supported as TargetOperation for type: {1}.", TargetOperation.Value.Value, targetType));
+          throw new InvalidOperationException(string.Format("Operation {0} is not supported as TargetOperation for type: {1}.", TargetOperation.ActualValue.Value, targetType));
       }
     }
@@ -259 +274 @@
     private void CalculateResult(IEnumerable<bool> values, Type targetType) {
       bool result;
-      switch (ReductionOperation.Value.Value) {
+      switch (ReductionOperation.ActualValue.Value) {
         case ReductionOperations.All:
           result = values.All(x => x);
@@ -267 +282 @@
           break;
         default:
-          throw new InvalidOperationException(string.Format("Operation {0} is not supported as ReductionOperation for type: {1}.", ReductionOperation.Value.Value, targetType));
+          throw new InvalidOperationException(string.Format("Operation {0} is not supported as ReductionOperation for type: {1}.", ReductionOperation.ActualValue.Value, targetType));
       }
 
       BoolValue target;
-      switch (TargetOperation.Value.Value) {
+      switch (TargetOperation.ActualValue.Value) {
         case ReductionOperations.Assign:
           target = InitializeTarget<BoolValue, bool>(targetType, true);
@@ -277 +292 @@
           break;
         default:
-          throw new InvalidOperationException(string.Format("Operation {0} is not supported as TargetOperation for type: {1}.", TargetOperation.Value.Value, targetType));
+          throw new InvalidOperationException(string.Format("Operation {0} is not supported as TargetOperation for type: {1}.", TargetOperation.ActualValue.Value, targetType));
       }
     }