Changeset 3602

Timestamp:

05/04/10 13:38:35 (15 years ago)

Author:

mkommend

Message:

implemented comments by swa and moved constraints from data to core (ticket #996)

Location:

trunk/sources

Files:

• HeuristicLab.Core/3.3/Collections/ConstraintCollection.cs (added)
• HeuristicLab.Core/3.3/Constraints (added)
• HeuristicLab.Core/3.3/Constraints/ComparisonConstraint.cs (copied) (copied from trunk/sources/HeuristicLab.Data/3.3/Constraints/ComparisonConstraint.cs) (1 diff)
• HeuristicLab.Core/3.3/Constraints/Constraint.cs (copied) (copied from trunk/sources/HeuristicLab.Data/3.3/Constraints/Constraint.cs) (7 diffs)
• HeuristicLab.Core/3.3/Constraints/ConstraintOperation.cs (added)
• HeuristicLab.Core/3.3/Constraints/EqualityConstraint.cs (added)
• HeuristicLab.Core/3.3/Constraints/IConstraint.cs (added)
• HeuristicLab.Core/3.3/Constraints/TypeCompatibilityConstraint.cs (added)
• HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj (modified) (1 diff)
• HeuristicLab.Data/3.3/Constraints (deleted)
• HeuristicLab.Data/3.3/HeuristicLab.Data-3.3.csproj (modified) (1 diff)

trunk/sources/HeuristicLab.Core/3.3/Constraints/ComparisonConstraint.cs

@@ -24 +24 @@
 using System.Linq;
 using System.Text;
-using HeuristicLab.Core;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Data {
+namespace HeuristicLab.Core {
   [StorableClass]
   [Item("ComparisonConstraint", "A constraint which checks for specified compare operation.")]
   public class ComparisonConstraint : Constraint {
-    /// <summary>
-    /// Protected default constructor for constructor chaining and cloning.
-    /// </summary>
-    [StorableConstructor]
-    protected ComparisonConstraint()
+    public ComparisonConstraint()
       : base() {
     }
-
-    public ComparisonConstraint(IItem constrainedValue, ComparisonOperation comparisonOperation, object comparisonValue)
-      : base() {
-      this.ConstrainedValue = constrainedValue;
-      this.ComparisonOperation = comparisonOperation;
-      this.ComparisonValue = comparisonValue;
+    [StorableConstructor]
+    protected ComparisonConstraint(bool deserializing) {
+    }
+    public ComparisonConstraint(IItem constrainedValue, ConstraintOperation comparisonOperation, object comparisonValue)
+      : base(constrainedValue, comparisonOperation, comparisonValue) {
+    }
+    public ComparisonConstraint(IItem constrainedValue, ConstraintOperation comparisonOperation, object comparisonValue, bool active)
+      : base(constrainedValue, comparisonOperation, comparisonOperation, active) {
     }
 
-    public override IEnumerable<ComparisonOperation> AllowedComparisonOperations {
-      get { return new List<ComparisonOperation>() { ComparisonOperation.Equal, ComparisonOperation.NotEqual, ComparisonOperation.Lesser, ComparisonOperation.LesserOrEqual, ComparisonOperation.Greater, ComparisonOperation.GreaterOrEqual }; }
+    public override IEnumerable<ConstraintOperation> AllowedConstraintOperations {
+      get { return new ConstraintOperation[6] { ConstraintOperation.Equal, ConstraintOperation.NotEqual, ConstraintOperation.Lesser, ConstraintOperation.LesserOrEqual, ConstraintOperation.Greater, ConstraintOperation.GreaterOrEqual }; }
     }
 
     protected override bool Check(object constrainedMember) {
+      if (constrainedMember == null)
+        return false;
+
       IComparable comparableMember = constrainedMember as IComparable;
       if (comparableMember == null)
         throw new InvalidOperationException("Constrained member must be of type IComparable to be used with ComparisonConstraint.");
 
-      int compareResult = comparableMember.CompareTo(this.ComparisonValue);
+      int compareResult = comparableMember.CompareTo(this.ConstraintData);
       bool result = false;
-      if (this.ComparisonOperation == ComparisonOperation.Lesser)
+      if (this.ConstraintOperation == ConstraintOperation.Lesser)
         result = compareResult < 0;
-      else if (this.ComparisonOperation == ComparisonOperation.LesserOrEqual)
+      else if (this.ConstraintOperation == ConstraintOperation.LesserOrEqual)
         result = compareResult <= 0;
-      else if (this.ComparisonOperation == ComparisonOperation.Equal)
+      else if (this.ConstraintOperation == ConstraintOperation.Equal)
         result = compareResult == 0;
-      else if (this.ComparisonOperation == ComparisonOperation.GreaterOrEqual)
+      else if (this.ConstraintOperation == ConstraintOperation.GreaterOrEqual)
         result = compareResult >= 0;
-      else if (this.ComparisonOperation == ComparisonOperation.Greater)
+      else if (this.ConstraintOperation == ConstraintOperation.Greater)
         result = compareResult > 0;
-      else if (this.ComparisonOperation == ComparisonOperation.NotEqual)
+      else if (this.ConstraintOperation == ConstraintOperation.NotEqual)
         result = compareResult != 0;
       else
-        throw new InvalidOperationException("CompareOperation " + this.ComparisonOperation + " is not defined for ComparisonConstraint.");
+        throw new InvalidOperationException("Constraint operation " + this.ConstraintOperation + " is not defined for ComparisonConstraint.");
 
+      return result;
+    }
+
+    protected override bool Check(object constrainedMember, out string errorMessage) {
+      bool result = Check(constrainedMember);
+      errorMessage = string.Empty;
+      if (!result)
+        errorMessage = constrainedMember.ToString() + " must be " + ConstraintOperation.ToString() + " than " + ConstraintData.ToString() + ".";
       return result;
     }

trunk/sources/HeuristicLab.Core/3.3/Constraints/Constraint.cs

@@ -24 +24 @@
 using System.Linq;
 using System.Text;
-using HeuristicLab.Core;
 using HeuristicLab.Common;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Data {
+namespace HeuristicLab.Core {
   [StorableClass]
   public abstract class Constraint : Item, IConstraint {
-    /// <summary>
-    /// Protected default constructor for constructor chaining, cloning and persisting of constraints.
-    /// </summary>
+    protected Constraint() {
+      this.Active = false;
+    }
     [StorableConstructor]
-    protected Constraint() {
-      this.Active = true;
+    protected Constraint(bool deserializing) {
     }
-
-    public Constraint(IItem constrainedValue,ComparisonOperation comparisonOperation, object comparisonValue)
+    protected Constraint(IItem constrainedValue, ConstraintOperation comparisonOperation, object comparisonValue)
       : this() {
       this.ConstrainedValue = constrainedValue;
-      this.ComparisonOperation = comparisonOperation;
-      this.ComparisonValue = comparisonValue;
+      this.ConstraintOperation = comparisonOperation;
+      this.ConstraintData = comparisonValue;
+    }
+    protected Constraint(IItem constrainedValue, ConstraintOperation comparisonOperation, object comparisonValue, bool active) {
+      this.ConstrainedValue = constrainedValue;
+      this.ConstraintOperation = comparisonOperation;
+      this.ConstraintData = comparisonValue;
+      this.Active = active;
     }
 
@@ -73 +76 @@
 
     [Storable]
-    private object comparisonValue;
-    public object ComparisonValue {
-      get { return this.comparisonValue; }
+    private object constraintData;
+    public object ConstraintData {
+      get { return this.constraintData; }
       set {
-        if (this.comparisonValue != value) {
-          this.comparisonValue = value;
-          this.OnComparisonValueChanged();
+        if (this.constraintData != value) {
+          this.constraintData = value;
+          this.OnConstraintDataChanged();
           this.OnToStringChanged();
         }
@@ -85 +88 @@
     }
 
-    public abstract IEnumerable<ComparisonOperation> AllowedComparisonOperations { get; }
+    public abstract IEnumerable<ConstraintOperation> AllowedConstraintOperations { get; }
     [Storable]
-    private ComparisonOperation comparisonOperation;
-    public ComparisonOperation ComparisonOperation {
-      get { return this.comparisonOperation; }
+    private ConstraintOperation constraintOperation;
+    public ConstraintOperation ConstraintOperation {
+      get { return this.constraintOperation; }
       set {
         if (value == null)
           throw new ArgumentNullException("Comparison operation cannot be null.");
-        if (!AllowedComparisonOperations.Contains(value))
+        if (!AllowedConstraintOperations.Contains(value))
           throw new ArgumentException("Comparison operation is not contained in the allowed ComparisonOperations.");
-        if (this.comparisonOperation != value) {
-          this.comparisonOperation = value;
-          this.OnComparisonOperationChanged();
+        if (this.constraintOperation != value) {
+          this.constraintOperation = value;
+          this.OnConstraintOperationChanged();
           this.OnToStringChanged();
         }
@@ -119 +122 @@
     protected abstract bool Check(object constrainedMember);
 
+    public bool Check(out string errorMessage) {
+      errorMessage = string.Empty;
+      if (!Active)
+        return true;
+
+      IItem constrainedMember = this.GetConstrainedMember();
+      return this.Check(constrainedMember, out errorMessage);
+    }
+
+    protected abstract bool Check(object constrainedMember, out string errorMessage);
+
     #region events
     public event EventHandler ActiveChanged;
@@ -127 +141 @@
     }
 
-    public event EventHandler ComparisonValueChanged;
-    protected virtual void OnComparisonValueChanged() {
-      EventHandler handler = ComparisonValueChanged;
+    public event EventHandler ConstraintDataChanged;
+    protected virtual void OnConstraintDataChanged() {
+      EventHandler handler = ConstraintDataChanged;
       if (handler != null)
         ActiveChanged(this, EventArgs.Empty);
     }
 
-    public event EventHandler ComparisonOperationChanged;
-    protected virtual void OnComparisonOperationChanged() {
-      EventHandler handler = ComparisonOperationChanged;
+    public event EventHandler ConstraintOperationChanged;
+    protected virtual void OnConstraintOperationChanged() {
+      EventHandler handler = ConstraintOperationChanged;
       if (handler != null)
         ActiveChanged(this, EventArgs.Empty);
@@ -151 +165 @@
         return "Could not determine constraint value.";
 
-      s += " " + comparisonOperation.ToString() + " ";
+      s += " " + ConstraintOperation.ToString() + " ";
 
-      if (comparisonValue != null)
-        s += comparisonValue.ToString();
+      if (constraintData != null)
+        s += constraintData.ToString();
       else
         s += "null";
@@ -166 +180 @@
       clone.constrainedValue = (IItem)cloner.Clone(this.constrainedValue);
 
-      IItem comparisonItem = this.comparisonValue as IItem;
-      if (comparisonItem != null)
-        clone.comparisonValue = (IItem)cloner.Clone(comparisonItem);
+      IItem constraintDataItem = this.constraintData as IItem;
+      ICloneable constraintDataCloneable = this.constraintData as ICloneable;
+      if (constraintDataItem != null)
+        clone.constraintData = cloner.Clone(constraintDataItem);
+      else if (constraintDataCloneable != null)
+        clone.constraintData = constraintDataCloneable.Clone();
       else
-        clone.comparisonValue = comparisonValue;
-      clone.comparisonOperation = this.comparisonOperation;
+        clone.constraintData = constraintData;
+
+      clone.constraintOperation = this.constraintOperation;
 
       return clone;

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

@@ -125 +125 @@
     <Compile Include="Collections\ValueParameterCollection.cs" />
     <Compile Include="Collections\VariableCollection.cs" />
+    <Compile Include="Constraints\ComparisonConstraint.cs" />
+    <Compile Include="Constraints\Constraint.cs" />
+    <Compile Include="Collections\ConstraintCollection.cs" />
+    <Compile Include="Constraints\ConstraintOperation.cs" />
+    <Compile Include="Constraints\EqualityConstraint.cs" />
+    <Compile Include="Constraints\IConstraint.cs" />
+    <Compile Include="Constraints\TypeCompatibilityConstraint.cs" />
     <Compile Include="Interfaces\ICheckedItemList.cs" />
     <Compile Include="Interfaces\ICheckedItemCollection.cs" />

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

@@ -105 +105 @@
     <Compile Include="Comparison.cs" />
     <Compile Include="ComparisonType.cs" />
-    <Compile Include="Constraints\ComparisonOperation.cs" />
-    <Compile Include="Constraints\TypeConstraint.cs" />
-    <Compile Include="Constraints\ComparisonConstraint.cs" />
-    <Compile Include="Constraints\Constraint.cs" />
-    <Compile Include="Constraints\EqualityConstraint.cs" />
-    <Compile Include="Constraints\IConstraint.cs" />
     <Compile Include="PercentValue.cs" />
     <Compile Include="DateTimeValue.cs" />