Index: trunk/sources/HeuristicLab.Constraints/AllSubOperatorsTypeConstraint.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/AllSubOperatorsTypeConstraint.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/AllSubOperatorsTypeConstraint.cs	(revision 1176)
@@ -29,7 +29,13 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// Constraint where all sub-operators have to be elements of a pre-defined group.
+  /// </summary>
   public class AllSubOperatorsTypeConstraint : ConstraintBase {
 
     private SubOperatorTypeConstraint groupConstraint;
+    /// <summary>
+    /// Gets all allowed sub-operators.
+    /// </summary>
     public IList<IOperator> AllowedSubOperators {
       get {
@@ -38,8 +44,12 @@
     }
 
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get { return "All sub-operators have to be elements of a pre-defined group."; }
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="AllSubOperatorsTypeConstraint"/>.
+    /// </summary>
     public AllSubOperatorsTypeConstraint()
       : base() {
@@ -47,4 +57,10 @@
     }
 
+    /// <summary>
+    /// Adds the given operator to the constraint.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.FireChanged"/> of base class 
+    /// <see cref="ConstraintBase"/>.</remarks>
+    /// <param name="op">The operator to add.</param>
     public void AddOperator(IOperator op) {
       groupConstraint.AddOperator(op);
@@ -52,4 +68,10 @@
     }
 
+    /// <summary>
+    /// Removes the given operator from the contraint.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.FireChanged"/> of base class 
+    /// <see cref="ConstraintBase"/>.</remarks>
+    /// <param name="op">The operator to remove.</param>
     public void RemoveOperator(IOperator op) {
       groupConstraint.RemoveOperator(op);
@@ -57,4 +79,9 @@
     }
 
+    /// <summary>
+    /// Checks whether the given element fulfills the current constraint.
+    /// </summary>
+    /// <param name="data">The item to check.</param>
+    /// <returns><c>true</c> if the constraint could be fulfilled, <c>false</c> otherwise.</returns>
     public override bool Check(IItem data) {
       IOperator op = data as IOperator;
@@ -70,8 +97,18 @@
     }
 
+    /// <summary>
+    /// Empties the current instance.
+    /// </summary>
     public void Clear() {
       groupConstraint.Clear();
     }
 
+    /// <summary>
+    /// Clones the current instance (deep clone).
+    /// </summary>
+    /// <remarks>Deep clone through <see cref="Auxiliary.Clone"/> method of helper class 
+    /// <see cref="Auxiliary"/>.</remarks>
+    /// <param name="clonedObjects">Dictionary of all already clone objects. (Needed to avoid cycles.)</param>
+    /// <returns>The cloned object as <see cref="AllSubOperatorsTypeConstraint"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       AllSubOperatorsTypeConstraint clone = new AllSubOperatorsTypeConstraint();
@@ -81,4 +118,9 @@
     }
 
+    /// <summary>
+    /// Creates a new instance of <see cref="AllSubOperatorsTypeConstraintView"/> to represent the current 
+    /// instance visually.
+    /// </summary>
+    /// <returns>The created view as <see cref="AllSubOperatorsTypeConstraintView"/>.</returns>
     public override IView CreateView() {
       return new AllSubOperatorsTypeConstraintView(groupConstraint);
@@ -86,4 +128,14 @@
 
     #region persistence
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>The sub-operators are saved as a child node with tag name 
+    /// <c>SubOperatorsGroupConstraint</c>.</remarks>
+    /// <param name="name">The (tag)name of the <see cref="XmlNode"/>.</param>
+    /// <param name="document">The <see cref="XmlDocument"/> where the data is saved.</param>
+    /// <param name="persistedObjects">The dictionary of all already persisted objects. 
+    /// (Needed to avoid cycles.)</param>
+    /// <returns>The saved <see cref="XmlNode"/>.</returns>
     public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
@@ -94,4 +146,12 @@
     }
 
+    /// <summary>
+    /// Loads the persisted constraint from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>The constraint must be saved in a specific way, see <see cref="GetXmlNode"/> for 
+    /// more information.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the instance is saved.</param>
+    /// <param name="restoredObjects">The dictionary of all already restored objects. 
+    /// (Needed to avoid cycles.)</param>
     public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
       base.Populate(node, restoredObjects);
Index: trunk/sources/HeuristicLab.Constraints/AllSubOperatorsTypeConstraintView.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/AllSubOperatorsTypeConstraintView.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/AllSubOperatorsTypeConstraintView.cs	(revision 1176)
@@ -30,7 +30,13 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// The visual representation of the <see cref="AllSubOperatorsTypeConstraint"/>.
+  /// </summary>
   public partial class AllSubOperatorsTypeConstraintView : ViewBase {
     private SubOperatorTypeConstraint constraint = new SubOperatorTypeConstraint();
 
+    /// <summary>
+    /// Gets or sets the SubOperatorTypeConstraint to display.
+    /// </summary>
     public SubOperatorTypeConstraint Constraint {
       get { return constraint; }
@@ -41,8 +47,16 @@
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="AllSubOperatorsTypeConstraintView"/>.
+    /// </summary>
     public AllSubOperatorsTypeConstraintView() {
       InitializeComponent();
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="AllSubOperatorsTypeConstraintView"/> with
+    /// the given <paramref name="constraint"/> to display.
+    /// </summary>
+    /// <param name="constraint">The constraint that should be displayed.</param>
     public AllSubOperatorsTypeConstraintView(SubOperatorTypeConstraint constraint) {
       this.constraint = constraint;
Index: trunk/sources/HeuristicLab.Constraints/AndConstraint.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/AndConstraint.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/AndConstraint.cs	(revision 1176)
@@ -28,6 +28,14 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// Constraint where all sub-constraints must be <c>true</c>.
+  /// </summary>
   public class AndConstraint : ConstraintBase, IViewable {
     private ItemList<IConstraint> clauses;
+    /// <summary>
+    /// Gets or sets the sub-constraints.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.OnChanged"/> of base class 
+    /// <see cref="ConstraintBase"/> in the setter.</remarks>
     public ItemList<IConstraint> Clauses {
       get { return clauses; }
@@ -38,4 +46,5 @@
     }
 
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get {
@@ -44,8 +53,16 @@
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="AndConstraint"/>.
+    /// </summary>
     public AndConstraint() {
       clauses = new ItemList<IConstraint>();
     }
 
+    /// <summary>
+    /// Checks whether the given element fulfills the current constraint.
+    /// </summary>
+    /// <param name="data">The item to check.</param>
+    /// <returns><c>true</c> if the constraint could be fulfilled, <c>false</c> otherwise.</returns>
     public override bool Check(IItem data) {
       bool result = true;
@@ -57,8 +74,20 @@
     }
 
+    /// <summary>
+    /// Creates a new instance of <see cref="AndConstraintView"/> to represent the current 
+    /// instance visually.
+    /// </summary>
+    /// <returns>The created view as <see cref="AndConstraintView"/>.</returns>
     public override IView CreateView() {
       return new AndConstraintView(this);
     }
 
+    /// <summary>
+    /// Clones the current instance (deep clone).
+    /// </summary>
+    /// <remarks>Deep clone through <see cref="Auxiliary.Clone"/> method of helper class 
+    /// <see cref="Auxiliary"/>.</remarks>
+    /// <param name="clonedObjects">Dictionary of all already clone objects. (Needed to avoid cycles.)</param>
+    /// <returns>The cloned object as <see cref="AndConstraint"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       AndConstraint clone = new AndConstraint();
@@ -69,4 +98,14 @@
 
     #region persistence
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>The sub-constraints are saved as a child node with tag name 
+    /// <c>Clauses</c>.</remarks>
+    /// <param name="name">The (tag)name of the <see cref="XmlNode"/>.</param>
+    /// <param name="document">The <see cref="XmlDocument"/> where the data is saved.</param>
+    /// <param name="persistedObjects">The dictionary of all already persisted objects. 
+    /// (Needed to avoid cycles.)</param>
+    /// <returns>The saved <see cref="XmlNode"/>.</returns>
     public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid,IStorable> persistedObjects) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
@@ -77,4 +116,12 @@
     }
 
+    /// <summary>
+    /// Loads the persisted constraint from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>The constraint must be saved in a specific way, see <see cref="GetXmlNode"/> for 
+    /// more information.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the instance is saved.</param>
+    /// <param name="restoredObjects">The dictionary of all already restored objects. 
+    /// (Needed to avoid cycles.)</param>
     public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
       base.Populate(node, restoredObjects);
Index: trunk/sources/HeuristicLab.Constraints/AndConstraintView.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/AndConstraintView.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/AndConstraintView.cs	(revision 1176)
@@ -31,5 +31,13 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// The visual representation of an <see cref="AndConstraint"/>.
+  /// </summary>
   public partial class AndConstraintView : ViewBase {
+    /// <summary>
+    /// Gets or sets the AndConstraint to represent visually.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="ViewBase"/>.</remarks>
+    /// No own data storage present. 
     public AndConstraint AndConstraint {
       get { return (AndConstraint)Item; }
@@ -37,7 +45,15 @@
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="AndConstraintView"/>.
+    /// </summary>
     public AndConstraintView() {
       InitializeComponent();
     }
+    /// <summary>
+    /// Initializes a new instance of <see cref="AndConstraintView"/> with the given 
+    /// <paramref name="andConstraint"/> to display.
+    /// </summary>
+    /// <param name="andConstraint">The constraint to represent visually.</param>
     public AndConstraintView(AndConstraint andConstraint)
       : this() {
@@ -45,8 +61,18 @@
     }
 
+    /// <summary>
+    /// Removes the eventhandler from the underlying <see cref="AndConstraint"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.RemoveItemEvents"/> of base class <see cref="ViewBase"/>.
+    /// </remarks>
     protected override void RemoveItemEvents() {
       AndConstraint.Changed -= new EventHandler(AndConstraint_Changed);
       base.RemoveItemEvents();
     }
+    /// <summary>
+    /// Adds an eventhandler to the underlying <see cref="AndConstraint"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.AddItemEvents"/> of base class <see cref="ViewBase"/>.
+    /// </remarks>
     protected override void AddItemEvents() {
       base.AddItemEvents();
@@ -54,4 +80,7 @@
     }
 
+    /// <summary>
+    /// Updates all controls with the latest values.
+    /// </summary>
     protected override void UpdateControls() {
       if (AndConstraint == null) {
Index: trunk/sources/HeuristicLab.Constraints/ConstraintBase.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/ConstraintBase.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/ConstraintBase.cs	(revision 1176)
@@ -27,9 +27,18 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// Base class for all constraints.
+  /// </summary>
   public abstract class ConstraintBase : ItemBase, IConstraint {
+    /// <inheritdoc select="summary"/>
     public virtual string Description {
       get { return "No constraint description available."; }
     }
 
+    /// <summary>
+    /// Checks whether the given data fulfills the current constraint.
+    /// </summary>
+    /// <param name="data">The item to check.</param>
+    /// <returns><c>true</c> if the constraint could be fulfilled, <c>false</c> otherwise.</returns>
     public abstract bool Check(IItem data);
   }
Index: trunk/sources/HeuristicLab.Constraints/DoubleBoundedConstraint.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/DoubleBoundedConstraint.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/DoubleBoundedConstraint.cs	(revision 1176)
@@ -29,6 +29,14 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// Constraint where a double value is limited by a one or two sided boundary.
+  /// </summary>
   public class DoubleBoundedConstraint : ConstraintBase {
     private double lowerBound;
+    /// <summary>
+    /// Gets or sets the lower bound of the limit.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.OnChanged"/> of base class <see cref="ConstraintBase"/>
+    /// in the setter.</remarks>
     public double LowerBound {
       get { return lowerBound; }
@@ -39,4 +47,9 @@
     }
     private bool lowerBoundIncluded;
+    /// <summary>
+    /// Gets or sets the boolean flag whether the lower bound should be included.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.OnChanged"/> of base class <see cref="ConstraintBase"/>
+    /// in the setter.</remarks>
     public bool LowerBoundIncluded {
       get { return lowerBoundIncluded; }
@@ -47,4 +60,9 @@
     }
     private bool lowerBoundEnabled;
+    /// <summary>
+    /// Gets or sets the boolean flag whether the lower bound should be enabled.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.OnChanged"/> of base class <see cref="ConstraintBase"/>
+    /// in the setter.</remarks>
     public bool LowerBoundEnabled {
       get { return lowerBoundEnabled; }
@@ -55,4 +73,9 @@
     }
     private double upperBound;
+    /// <summary>
+    /// Gets or sets the upper bound of the limit.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.OnChanged"/> of base class <see cref="ConstraintBase"/>
+    /// in the setter.</remarks>
     public double UpperBound {
       get { return upperBound; }
@@ -63,4 +86,9 @@
     }
     private bool upperBoundIncluded;
+    /// <summary>
+    /// Gets or sets the boolean flag whether the upper bound should be included.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.OnChanged"/> of base class <see cref="ConstraintBase"/>
+    /// in the setter.</remarks>
     public bool UpperBoundIncluded {
       get { return upperBoundIncluded; }
@@ -71,4 +99,9 @@
     }
     private bool upperBoundEnabled;
+    /// <summary>
+    /// Gets or sets the boolean flag whether the upper bound should be enabled.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.OnChanged"/> of base class <see cref="ConstraintBase"/>
+    /// in the setter.</remarks>
     public bool UpperBoundEnabled {
       get { return upperBoundEnabled; }
@@ -79,16 +112,32 @@
     }
 
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get { return "The double is limited one or two sided by a lower and/or upper boundary"; }
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="DoubleBoundedConstraint"/>.
+    /// </summary>
     public DoubleBoundedConstraint()
       : this(double.MinValue, double.MaxValue) {
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="DoubleBoundedConstraint"/> with the two given boundaries.
+    /// </summary>
+    /// <param name="lowerBound">The lower bound of the constraint.</param>
+    /// <param name="upperBound">The upper bound of the constraint.</param>
     public DoubleBoundedConstraint(double lowerBound, double upperBound)
       : this(lowerBound, true, upperBound, true) {
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="DoubleBoundedConstraint"/> with the given parameters.
+    /// </summary>
+    /// <param name="lowerBound">The lower bound of the constraint.</param>
+    /// <param name="lowerBoundIncluded">Boolean flag whether the lower bound should be included.</param>
+    /// <param name="upperBound">The upper bound of the constraint.</param>
+    /// <param name="upperBoundIncluded">Boolean flag whether the upper bound should be included.</param>
     public DoubleBoundedConstraint(double lowerBound, bool lowerBoundIncluded, double upperBound, bool upperBoundIncluded)
       : base() {
@@ -102,4 +151,9 @@
 
 
+    /// <summary>
+    /// Checks whether the given element fulfills the current constraint.
+    /// </summary>
+    /// <param name="data">The item to check.</param>
+    /// <returns><c>true</c> if the constraint could be fulfilled, <c>false</c> otherwise.</returns>
     public override bool Check(IItem data) {
       ConstrainedDoubleData d = (data as ConstrainedDoubleData);
@@ -112,8 +166,18 @@
     }
 
+    /// <summary>
+    /// Creates a new instance of <see cref="DoubleBoundedConstraintView"/> to represent the current 
+    /// instance visually.
+    /// </summary>
+    /// <returns>The created view as <see cref="DoubleBoundedConstraintView"/>.</returns>
     public override IView CreateView() {
       return new DoubleBoundedConstraintView(this);
     }
 
+    /// <summary>
+    /// Clones the current instance (deep clone).
+    /// </summary>
+    /// <param name="clonedObjects">Dictionary of all already clone objects. (Needed to avoid cycles.)</param>
+    /// <returns>The cloned object as <see cref="DoubleBoundedConstraint"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       DoubleBoundedConstraint clone = new DoubleBoundedConstraint();
@@ -129,4 +193,13 @@
 
     #region persistence
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>The properties of the current instance are saved as attributes with special tag names.</remarks>
+    /// <param name="name">The (tag)name of the <see cref="XmlNode"/>.</param>
+    /// <param name="document">The <see cref="XmlDocument"/> where the data is saved.</param>
+    /// <param name="persistedObjects">The dictionary of all already persisted objects. 
+    /// (Needed to avoid cycles.)</param>
+    /// <returns>The saved <see cref="XmlNode"/>.</returns>
     public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
@@ -152,4 +225,12 @@
     }
 
+    /// <summary>
+    /// Loads the persisted constraint from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>The constraint must be saved in a specific way, see <see cref="GetXmlNode"/> for 
+    /// more information.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the instance is saved.</param>
+    /// <param name="restoredObjects">The dictionary of all already restored objects. 
+    /// (Needed to avoid cycles.)</param>
     public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
       base.Populate(node, restoredObjects);
Index: trunk/sources/HeuristicLab.Constraints/DoubleBoundedConstraintView.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/DoubleBoundedConstraintView.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/DoubleBoundedConstraintView.cs	(revision 1176)
@@ -31,5 +31,13 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// The visual representation of a <see cref="DoubleBoundedConstraint"/>.
+  /// </summary>
   public partial class DoubleBoundedConstraintView : ViewBase {
+    /// <summary>
+    /// Gets or sets the DoubleBoundedConstraint to represent visually.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="ViewBase"/>.
+    /// No own data storage present.</remarks>
     public DoubleBoundedConstraint DoubleBoundedConstraint {
       get { return (DoubleBoundedConstraint)Item; }
@@ -37,8 +45,16 @@
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="DoubleBoundedConstraintView"/>.
+    /// </summary>
     public DoubleBoundedConstraintView() {
       InitializeComponent();
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="DoubleBoundedConstraintView"/> with the given
+    /// <paramref name="doubleBoundedConstraint"/> to display.
+    /// </summary>
+    /// <param name="doubleBoundedConstraint">The constraint to represent visually.</param>
     public DoubleBoundedConstraintView(DoubleBoundedConstraint doubleBoundedConstraint)
       : this() {
@@ -46,4 +62,9 @@
     }
 
+    /// <summary>
+    /// Removes the eventhandler from the underlying <see cref="DoubleBoundedConstraint"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.RemoveItemEvents"/> of base class <see cref="ViewBase"/>.
+    /// </remarks>
     protected override void RemoveItemEvents() {
       DoubleBoundedConstraint.Changed -= new EventHandler(DoubleBoundedConstraint_Changed); 
@@ -51,4 +72,9 @@
     }
 
+    /// <summary>
+    /// Adds an eventhandler to the underlying <see cref="DoubleBoundedConstraint"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.AddItemEvents"/> of base class <see cref="ViewBase"/>.
+    /// </remarks>
     protected override void AddItemEvents() {
       base.AddItemEvents();
@@ -56,4 +82,8 @@
     }
 
+    /// <summary>
+    /// Updates all controls with the latest values.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.UpdateControls"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void UpdateControls() {
       base.UpdateControls();
Index: trunk/sources/HeuristicLab.Constraints/HeuristicLabConstraintsPlugin.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/HeuristicLabConstraintsPlugin.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/HeuristicLabConstraintsPlugin.cs	(revision 1176)
@@ -26,4 +26,7 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// Plugin class for HeuristicLab.Constraints plugin.
+  /// </summary>
   [ClassInfo(Name = "HeuristicLab.Constraints-3.2")]
   [PluginFile(Filename = "HeuristicLab.Constraints-3.2.dll", Filetype = PluginFileType.Assembly)]
Index: trunk/sources/HeuristicLab.Constraints/IntBoundedConstraint.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/IntBoundedConstraint.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/IntBoundedConstraint.cs	(revision 1176)
@@ -28,6 +28,14 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// Constraint where an integer value is limited by a one or two sided boundary.
+  /// </summary>
   public class IntBoundedConstraint : ConstraintBase {
     private int lowerBound;
+    /// <summary>
+    /// Gets or sets the lower bound of the limit.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.OnChanged"/> of base class <see cref="ConstraintBase"/>
+    /// in the setter.</remarks>
     public int LowerBound {
       get { return lowerBound; }
@@ -38,4 +46,9 @@
     }
     private bool lowerBoundIncluded;
+    /// <summary>
+    /// Gets or sets the boolean flag whether the lower bound should be included.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.OnChanged"/> of base class <see cref="ConstraintBase"/>
+    /// in the setter.</remarks>
     public bool LowerBoundIncluded {
       get { return lowerBoundIncluded; }
@@ -46,4 +59,9 @@
     }
     private bool lowerBoundEnabled;
+    /// <summary>
+    /// Gets or sets the boolean flag whether the lower bound should be enabled.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.OnChanged"/> of base class <see cref="ConstraintBase"/>
+    /// in the setter.</remarks>
     public bool LowerBoundEnabled {
       get { return lowerBoundEnabled; }
@@ -54,4 +72,9 @@
     }
     private int upperBound;
+    /// <summary>
+    /// Gets or sets the upper bound of the limit.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.OnChanged"/> of base class <see cref="ConstraintBase"/>
+    /// in the setter.</remarks>
     public int UpperBound {
       get { return upperBound; }
@@ -62,4 +85,9 @@
     }
     private bool upperBoundIncluded;
+    /// <summary>
+    /// Gets or sets the boolean flag whether the upper bound should be included.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.OnChanged"/> of base class <see cref="ConstraintBase"/>
+    /// in the setter.</remarks>
     public bool UpperBoundIncluded {
       get { return upperBoundIncluded; }
@@ -70,4 +98,9 @@
     }
     private bool upperBoundEnabled;
+    /// <summary>
+    /// Gets or sets the boolean flag whether the upper bound should be enabled.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.OnChanged"/> of base class <see cref="ConstraintBase"/>
+    /// in the setter.</remarks>
     public bool UpperBoundEnabled {
       get { return upperBoundEnabled; }
@@ -78,12 +111,21 @@
     }
 
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get { return "The integer is limited one or two sided by a lower and/or upper boundary"; }
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="IntBoundedConstraint"/>.
+    /// </summary>
     public IntBoundedConstraint()
       : this(int.MinValue, int.MaxValue) {
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="IntBoundedConstraint"/> with the two given boundaries.
+    /// </summary>
+    /// <param name="low">The lower bound of the constraint.</param>
+    /// <param name="high">The upper bound of the constraint.</param>
     public IntBoundedConstraint(int low, int high) : base() {
       lowerBound = low;
@@ -95,4 +137,9 @@
     }
 
+    /// <summary>
+    /// Checks whether the given element fulfills the current constraint.
+    /// </summary>
+    /// <param name="data">The item to check.</param>
+    /// <returns><c>true</c> if the constraint could be fulfilled, <c>false</c> otherwise.</returns>
     public override bool Check(IItem data) {
       ConstrainedIntData d = (data as ConstrainedIntData);
@@ -105,8 +152,18 @@
     }
 
+    /// <summary>
+    /// Creates a new instance of <see cref="IntBoundedConstraintView"/> to represent the current 
+    /// instance visually.
+    /// </summary>
+    /// <returns>The created view as <see cref="IntBoundedConstraintView"/>.</returns>
     public override IView CreateView() {
       return new IntBoundedConstraintView(this);
     }
 
+    /// <summary>
+    /// Clones the current instance (deep clone).
+    /// </summary>
+    /// <param name="clonedObjects">Dictionary of all already clone objects. (Needed to avoid cycles.)</param>
+    /// <returns>The cloned object as <see cref="IntBoundedConstraint"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       IntBoundedConstraint clone = new IntBoundedConstraint();
@@ -122,4 +179,13 @@
 
     #region persistence
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>The properties of the current instance are saved as attributes with special tag names.</remarks>
+    /// <param name="name">The (tag)name of the <see cref="XmlNode"/>.</param>
+    /// <param name="document">The <see cref="XmlDocument"/> where the data is saved.</param>
+    /// <param name="persistedObjects">The dictionary of all already persisted objects. 
+    /// (Needed to avoid cycles.)</param>
+    /// <returns>The saved <see cref="XmlNode"/>.</returns>
     public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
@@ -145,4 +211,12 @@
     }
 
+    /// <summary>
+    /// Loads the persisted constraint from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>The constraint must be saved in a specific way, see <see cref="GetXmlNode"/> for 
+    /// more information.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the instance is saved.</param>
+    /// <param name="restoredObjects">The dictionary of all already restored objects. 
+    /// (Needed to avoid cycles.)</param>
     public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
       base.Populate(node, restoredObjects);
Index: trunk/sources/HeuristicLab.Constraints/IntBoundedConstraintView.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/IntBoundedConstraintView.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/IntBoundedConstraintView.cs	(revision 1176)
@@ -31,5 +31,13 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// The visual representation of an <see cref="IntBoundedConstraint"/>.
+  /// </summary>
   public partial class IntBoundedConstraintView : ViewBase {
+    /// <summary>
+    /// Gets or sets the the IntBoundedConstraint to represent visually.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="ViewBase"/>.
+    /// No own data storage present.</remarks>
     public IntBoundedConstraint IntBoundedConstraint {
       get { return (IntBoundedConstraint)Item; }
@@ -37,8 +45,16 @@
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="IntBoundedConstraintView"/>.
+    /// </summary>
     public IntBoundedConstraintView() {
       InitializeComponent();
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="IntBoundedConstraintView"/> with the given
+    /// <paramref name="intBoundedConstraint"/> to display.
+    /// </summary>
+    /// <param name="intBoundedConstraint">The constraint to represent visually.</param>
     public IntBoundedConstraintView(IntBoundedConstraint intBoundedConstraint)
       : this() {
@@ -46,4 +62,9 @@
     }
 
+    /// <summary>
+    /// Removes the eventhandler from the underlying <see cref="IntBoundedConstraint"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.RemoveItemEvents"/> of base class <see cref="ViewBase"/>.
+    /// </remarks>
     protected override void RemoveItemEvents() {
       IntBoundedConstraint.Changed -= new EventHandler(IntBoundedConstraint_Changed);
@@ -51,4 +72,9 @@
     }
 
+    /// <summary>
+    /// Adds an eventhandler to the underlying <see cref="IntBoundedConstraint"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.AddItemEvents"/> of base class <see cref="ViewBase"/>.
+    /// </remarks>
     protected override void AddItemEvents() {
       base.AddItemEvents();
@@ -56,4 +82,8 @@
     }
 
+    /// <summary>
+    /// Updates all controls with the latest values.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.UpdateControls"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void UpdateControls() {
       base.UpdateControls();
Index: trunk/sources/HeuristicLab.Constraints/IsIntegerConstraint.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/IsIntegerConstraint.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/IsIntegerConstraint.cs	(revision 1176)
@@ -27,9 +27,18 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// Constraint that allows only integer values.
+  /// </summary>
   public class IsIntegerConstraint : ConstraintBase{
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get { return "Allows only integer values."; }
     }
 
+    /// <summary>
+    /// Checks whether the given element fulfills the current constraint.
+    /// </summary>
+    /// <param name="item">The item to check.</param>
+    /// <returns><c>true</c> if the constraint could be fulfilled, <c>false</c> otherwise.</returns>
     public override bool Check(IItem item) {
       // ConstrainedIntData is always integer => just return true
Index: trunk/sources/HeuristicLab.Constraints/ItemTypeConstraint.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/ItemTypeConstraint.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/ItemTypeConstraint.cs	(revision 1176)
@@ -28,6 +28,16 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// Constraint that limits the type of a given item.
+  /// </summary>
+  /// <remarks>If the item is a <see cref="ConstrainedItemList"/>, any containing elements are limited to 
+  /// the type and not the <see cref="ConstrainedItemList"/> itself.</remarks>
   public class ItemTypeConstraint : ConstraintBase {
     private Type type;
+    /// <summary>
+    /// Gets or sets the type to which the items should be limited.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.OnChanged"/> of base class <see cref="ConstraintBase"/>
+    /// in the setter.</remarks>
     public Type Type {
       get { return type; }
@@ -38,4 +48,5 @@
     }
 
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get {
@@ -45,12 +56,25 @@
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="ItemTypeConstraint"/> with the <c>Type</c> property
+    /// set to <see cref="ItemBase"/> as default.
+    /// </summary>
     public ItemTypeConstraint() {
       type = typeof(ItemBase);
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="ItemTypeConstraint"/> with the given <paramref name="type"/>.
+    /// </summary>
+    /// <param name="type">The type the items should be limited to.</param>
     public ItemTypeConstraint(Type type) {
       this.type = type;
     }
 
+    /// <summary>
+    /// Checks whether the given element fulfills the current constraint.
+    /// </summary>
+    /// <param name="data">The item to check.</param>
+    /// <returns><c>true</c> if the constraint could be fulfilled, <c>false</c> otherwise.</returns>
     public override bool Check(IItem data) {
       ConstrainedItemList list = (data as ConstrainedItemList);
@@ -63,4 +87,9 @@
     }
 
+    /// <summary>
+    /// Creates a new instance of <see cref="ItemTypeConstraintView"/> to represent the current 
+    /// instance visually.
+    /// </summary>
+    /// <returns>The created view as <see cref="ItemTypeConstraintView"/>.</returns>
     public override IView CreateView() {
       return new ItemTypeConstraintView(this);
@@ -68,4 +97,9 @@
 
     #region clone & persistence
+    /// <summary>
+    /// Clones the current instance (deep clone).
+    /// </summary>
+    /// <param name="clonedObjects">Dictionary of all already clone objects. (Needed to avoid cycles.)</param>
+    /// <returns>The cloned object as <see cref="ItemTypeConstraint"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       ItemTypeConstraint clone = new ItemTypeConstraint(type);
@@ -74,4 +108,13 @@
     }
 
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>The type of the current instance is saved as attribute with tag name <c>ItemType</c>.</remarks>
+    /// <param name="name">The (tag)name of the <see cref="XmlNode"/>.</param>
+    /// <param name="document">The <see cref="XmlDocument"/> where the data is saved.</param>
+    /// <param name="persistedObjects">The dictionary of all already persisted objects. 
+    /// (Needed to avoid cycles.)</param>
+    /// <returns>The saved <see cref="XmlNode"/>.</returns>
     public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
@@ -82,4 +125,12 @@
     }
 
+    /// <summary>
+    /// Loads the persisted constraint from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>The constraint must be saved in a specific way, see <see cref="GetXmlNode"/> for 
+    /// more information.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the instance is saved.</param>
+    /// <param name="restoredObjects">The dictionary of all already restored objects. 
+    /// (Needed to avoid cycles.)</param>
     public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
       base.Populate(node, restoredObjects);
Index: trunk/sources/HeuristicLab.Constraints/ItemTypeConstraintView.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/ItemTypeConstraintView.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/ItemTypeConstraintView.cs	(revision 1176)
@@ -31,5 +31,13 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// The visual representation of an <see cref="ItemTypeConstraint"/>.
+  /// </summary>
   public partial class ItemTypeConstraintView : ViewBase {
+    /// <summary>
+    /// Gets or sets the ItemTypeConstraint to represent visually.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="ViewBase"/>.
+    /// No own data storage present.</remarks>
     private ItemTypeConstraint ItemTypeConstraint {
       get { return (ItemTypeConstraint)base.Item; }
@@ -37,4 +45,7 @@
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="ItemTypeConstraintView"/>.
+    /// </summary>
     public ItemTypeConstraintView() {
       InitializeComponent();
@@ -42,4 +53,9 @@
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="ItemTypeConstraintView"/> with the given 
+    /// <paramref name="itemTypeConstraint"/> to display.
+    /// </summary>
+    /// <param name="itemTypeConstraint">The constraint to represent visually.</param>
     public ItemTypeConstraintView(ItemTypeConstraint itemTypeConstraint)
       : this() {
@@ -47,4 +63,9 @@
     }
 
+    /// <summary>
+    /// Removes the eventhandler from the underlying <see cref="ItemTypeConstraint"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.RemoveItemEvents"/> of base class <see cref="ViewBase"/>.
+    /// </remarks>
     protected override void RemoveItemEvents() {
       ItemTypeConstraint.Changed -= new EventHandler(ItemTypeConstraint_Changed);
@@ -52,4 +73,9 @@
     }
 
+    /// <summary>
+    /// Adds an eventhandler to the underlying <see cref="ItemTypeConstraint"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.AddItemEvents"/> of base class <see cref="ViewBase"/>.
+    /// </remarks>
     protected override void AddItemEvents() {
       base.AddItemEvents();
@@ -61,4 +87,8 @@
     }
 
+    /// <summary>
+    /// Updates all controls with the latest values.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.UpdateControls"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void UpdateControls() {
       base.UpdateControls();
Index: trunk/sources/HeuristicLab.Constraints/NotConstraint.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/NotConstraint.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/NotConstraint.cs	(revision 1176)
@@ -28,6 +28,14 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// Constraint where its sub-constraint must be false to be true.
+  /// </summary>
   public class NotConstraint : ConstraintBase {
     private ConstraintBase subConstraint;
+    /// <summary>
+    /// Gets or sets the sub-constraint.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.OnChanged"/> of base class 
+    /// <see cref="ConstraintBase"/> in the setter.</remarks>
     public ConstraintBase SubConstraint {
       get { return subConstraint; }
@@ -37,4 +45,5 @@
       }
     }
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get {
@@ -42,16 +51,34 @@
       }
     }
+    /// <summary>
+    /// Initializes a new instance of <see cref="NotConstraint"/>.
+    /// </summary>
     public NotConstraint()
       : base() {
     }
 
+    /// <summary>
+    /// Checks whether the given element fulfills the current constraint.
+    /// </summary>
+    /// <param name="data">The item to check.</param>
+    /// <returns><c>true</c> if the constraint could be fulfilled, <c>false</c> otherwise.</returns>
     public override bool Check(IItem data) {
       return (subConstraint == null) || (!subConstraint.Check(data));
     }
 
+    /// <summary>
+    /// Creates a new instance of <see cref="NotConstraintView"/> to represent the current 
+    /// instance visually.
+    /// </summary>
+    /// <returns>The created view as <see cref="NotConstraintView"/>.</returns>
     public override IView CreateView() {
       return new NotConstraintView(this);
     }
 
+    /// <summary>
+    /// Clones the current instance (deep clone).
+    /// </summary>
+    /// <param name="clonedObjects">Dictionary of all already clone objects. (Needed to avoid cycles.)</param>
+    /// <returns>The cloned object as <see cref="NotConstraint"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       NotConstraint clone = new NotConstraint();
@@ -63,4 +90,14 @@
 
     #region persistence
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>The sub-constraint is saved as a child node with tag name 
+    /// <c>SubConstraint</c>.</remarks>
+    /// <param name="name">The (tag)name of the <see cref="XmlNode"/>.</param>
+    /// <param name="document">The <see cref="XmlDocument"/> where the data is saved.</param>
+    /// <param name="persistedObjects">The dictionary of all already persisted objects. 
+    /// (Needed to avoid cycles.)</param>
+    /// <returns>The saved <see cref="XmlNode"/>.</returns>
     public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
@@ -72,4 +109,12 @@
     }
 
+    /// <summary>
+    /// Loads the persisted constraint from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>The constraint must be saved in a specific way, see <see cref="GetXmlNode"/> for 
+    /// more information.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the instance is saved.</param>
+    /// <param name="restoredObjects">The dictionary of all already restored objects. 
+    /// (Needed to avoid cycles.)</param>
     public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
       base.Populate(node, restoredObjects);
Index: trunk/sources/HeuristicLab.Constraints/NotConstraintView.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/NotConstraintView.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/NotConstraintView.cs	(revision 1176)
@@ -32,7 +32,16 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// Visual representation of a <see cref="NotConstraint"/>.
+  /// </summary>
   public partial class NotConstraintView : ViewBase {
     private Type[] itemTypes;
 
+    /// <summary>
+    /// Gets or sets the NotConstraint to represent visually.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="ViewBase"/>.
+    /// No own data storage present.<br/>
+    /// Calls <see cref="ViewBase.Refresh"/> in the setter.</remarks>
     public NotConstraint NotConstraint {
       get { return (NotConstraint)Item; }
@@ -44,4 +53,7 @@
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="NotConstraintView"/>.
+    /// </summary>
     public NotConstraintView() {
       InitializeComponent();
@@ -55,4 +67,10 @@
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="NotConstraintView"/> with the given
+    /// <paramref name="notConstraint"/> to display.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.Refresh"/> in the setter.</remarks>
+    /// <param name="notConstraint">The constraint to represent visually.</param>
     public NotConstraintView(NotConstraint notConstraint)
       : this() {
@@ -62,8 +80,18 @@
     }
 
+    /// <summary>
+    /// Removes the eventhandler from the underlying <see cref="NotConstraint"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.RemoveItemEvents"/> of base class <see cref="ViewBase"/>.
+    /// </remarks>
     protected override void RemoveItemEvents() {
       NotConstraint.Changed -= new EventHandler(NotConstraint_Changed);
       base.RemoveItemEvents();
     }
+    /// <summary>
+    /// Adds an eventhandler to the underlying <see cref="NotConstraint"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.AddItemEvents"/> of base class <see cref="ViewBase"/>.
+    /// </remarks>
     protected override void AddItemEvents() {
       base.AddItemEvents();
@@ -71,4 +99,8 @@
     }
 
+    /// <summary>
+    /// Updates all controls with the latest values.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.UpdateControls"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void UpdateControls() {
       base.UpdateControls();
Index: trunk/sources/HeuristicLab.Constraints/NumberOfSubOperatorsConstraint.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/NumberOfSubOperatorsConstraint.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/NumberOfSubOperatorsConstraint.cs	(revision 1176)
@@ -29,24 +29,43 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// Constraint where the number of sub-operators must be within a specific range.
+  /// </summary>
   public class NumberOfSubOperatorsConstraint : ConstraintBase {
     private IntData minOperators;
     private IntData maxOperators;
 
+    /// <summary>
+    /// Gets the maximum number of sub-operators.
+    /// </summary>
     public IntData MaxOperators {
       get { return maxOperators; }
     }
 
+    /// <summary>
+    /// Gets the minimum number of sub-operators.
+    /// </summary>
     public IntData MinOperators {
       get { return minOperators; }
     }
 
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get { return "Number of sub-operators has to be between " + MinOperators.ToString() + " and " + MaxOperators.ToString() + "."; }
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="NumberOfSubOperatorsConstraint"/>.
+    /// </summary>
     public NumberOfSubOperatorsConstraint()
       : this(0,0) {
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="NumberOfSubOperatorsConstraint"/> with the minimum and 
+    /// the maximum number of sub-operators.
+    /// </summary>
+    /// <param name="min">The minimum number of sub-operators.</param>
+    /// <param name="max">The maximum number of sub-operators.</param>
     public NumberOfSubOperatorsConstraint(int min, int max) : base() {
       minOperators = new IntData(min);
@@ -54,4 +73,9 @@
     }
 
+    /// <summary>
+    /// Checks whether the given element fulfills the current constraint.
+    /// </summary>
+    /// <param name="data">The item to check.</param>
+    /// <returns><c>true</c> if the constraint could be fulfilled, <c>false</c> otherwise.</returns>
     public override bool Check(IItem data) {
       IOperator op = data as IOperator;
@@ -61,4 +85,9 @@
     }
 
+    /// <summary>
+    /// Clones the current instance (deep clone).
+    /// </summary>
+    /// <param name="clonedObjects">Dictionary of all already clone objects. (Needed to avoid cycles.)</param>
+    /// <returns>The cloned object as <see cref="AndConstraint"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       NumberOfSubOperatorsConstraint clone = new NumberOfSubOperatorsConstraint();
@@ -69,4 +98,9 @@
     }
 
+    /// <summary>
+    /// Creates a new instance of <see cref="NumberOfSubOperatorsConstraintView"/> to represent the current 
+    /// instance visually.
+    /// </summary>
+    /// <returns>The created view as <see cref="NumberOfSubOperatorsConstraintView"/>.</returns>
     public override IView CreateView() {
       return new NumberOfSubOperatorsConstraintView(this);
@@ -74,4 +108,14 @@
 
     #region persistence
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>The minimum and the maximum number of sub-operators are saved as child nodes with tag
+    /// names <c>min</c> and <c>max</c>.</remarks>
+    /// <param name="name">The (tag)name of the <see cref="XmlNode"/>.</param>
+    /// <param name="document">The <see cref="XmlDocument"/> where the data is saved.</param>
+    /// <param name="persistedObjects">The dictionary of all already persisted objects. 
+    /// (Needed to avoid cycles.)</param>
+    /// <returns>The saved <see cref="XmlNode"/>.</returns>
     public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid,IStorable> persistedObjects) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
@@ -83,4 +127,12 @@
     }
 
+    /// <summary>
+    /// Loads the persisted constraint from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>The constraint must be saved in a specific way, see <see cref="GetXmlNode"/> for 
+    /// more information.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the instance is saved.</param>
+    /// <param name="restoredObjects">The dictionary of all already restored objects. 
+    /// (Needed to avoid cycles.)</param>
     public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
       base.Populate(node, restoredObjects);
Index: trunk/sources/HeuristicLab.Constraints/NumberOfSubOperatorsConstraintView.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/NumberOfSubOperatorsConstraintView.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/NumberOfSubOperatorsConstraintView.cs	(revision 1176)
@@ -30,11 +30,22 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// Visual representation of a <see cref="NumberOfSubOperatorsConstraint"/>.
+  /// </summary>
   public partial class NumberOfSubOperatorsConstraintView : ViewBase {
     private NumberOfSubOperatorsConstraint constraint;
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="NumberOfSubOperatorsConstraintView"/>.
+    /// </summary>
     public NumberOfSubOperatorsConstraintView() {
       InitializeComponent();
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="NumberOfSubOperatorsConstraintView"/>
+    /// with the given <paramref name="constraint"/> to display.
+    /// </summary>
+    /// <param name="constraint">The constraint to represent visually.</param>
     public NumberOfSubOperatorsConstraintView(NumberOfSubOperatorsConstraint constraint) {
       InitializeComponent();
Index: trunk/sources/HeuristicLab.Constraints/OrConstraint.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/OrConstraint.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/OrConstraint.cs	(revision 1176)
@@ -28,6 +28,14 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// Constraint where at least one sub-constraint must be true.
+  /// </summary>
   public class OrConstraint : ConstraintBase, IViewable {
     private ItemList<IConstraint> clauses;
+    /// <summary>
+    /// Gets or sets the sub-constraints.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.OnChanged"/> of base class 
+    /// <see cref="ConstraintBase"/> in the setter.</remarks>
     public ItemList<IConstraint> Clauses {
       get { return clauses; }
@@ -38,4 +46,5 @@
     }
 
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get {
@@ -44,8 +53,16 @@
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="OrConstraint"/>.
+    /// </summary>
     public OrConstraint() {
       clauses = new ItemList<IConstraint>();
     }
 
+    /// <summary>
+    /// Checks whether the given element fulfills the current constraint.
+    /// </summary>
+    /// <param name="data">The item to check.</param>
+    /// <returns><c>true</c> if the constraint could be fulfilled, <c>false</c> otherwise.</returns>
     public override bool Check(IItem data) {
       bool result = false;
@@ -57,8 +74,20 @@
     }
 
+    /// <summary>
+    /// Creates a new instance of <see cref="OrConstraintView"/> to represent the current 
+    /// instance visually.
+    /// </summary>
+    /// <returns>The created view as <see cref="OrConstraintView"/>.</returns>
     public override IView CreateView() {
       return new OrConstraintView(this);
     }
 
+    /// <summary>
+    /// Clones the current instance (deep clone).
+    /// </summary>
+    /// <remarks>Deep clone through <see cref="Auxiliary.Clone"/> method of helper class 
+    /// <see cref="Auxiliary"/>.</remarks>
+    /// <param name="clonedObjects">Dictionary of all already clone objects. (Needed to avoid cycles.)</param>
+    /// <returns>The cloned object as <see cref="OrConstraint"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       OrConstraint clone = new OrConstraint();
@@ -69,4 +98,14 @@
 
     #region persistence
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>The sub-constraints are saved as a child node with tag name 
+    /// <c>Clauses</c>.</remarks>
+    /// <param name="name">The (tag)name of the <see cref="XmlNode"/>.</param>
+    /// <param name="document">The <see cref="XmlDocument"/> where the data is saved.</param>
+    /// <param name="persistedObjects">The dictionary of all already persisted objects. 
+    /// (Needed to avoid cycles.)</param>
+    /// <returns>The saved <see cref="XmlNode"/>.</returns>
     public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid,IStorable> persistedObjects) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
@@ -77,4 +116,12 @@
     }
 
+    /// <summary>
+    /// Loads the persisted constraint from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>The constraint must be saved in a specific way, see <see cref="GetXmlNode"/> for 
+    /// more information.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the instance is saved.</param>
+    /// <param name="restoredObjects">The dictionary of all already restored objects. 
+    /// (Needed to avoid cycles.)</param>
     public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
       base.Populate(node, restoredObjects);
Index: trunk/sources/HeuristicLab.Constraints/OrConstraintView.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/OrConstraintView.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/OrConstraintView.cs	(revision 1176)
@@ -31,4 +31,7 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// Visual representation of an <see cref="OrConstraint"/>.
+  /// </summary>
   public partial class OrConstraintView : ViewBase {
     private OrConstraint OrConstraint {
@@ -37,7 +40,15 @@
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="OrConstraintView"/>.
+    /// </summary>
     public OrConstraintView() {
       InitializeComponent();
     }
+    /// <summary>
+    /// Initializes a new instance of <see cref="OrConstraintView"/> with the given
+    /// <paramref name="orConstraint"/> to display.
+    /// </summary>
+    /// <param name="orConstraint">The constraint to represent visually.</param>
     public OrConstraintView(OrConstraint orConstraint)
       : this() {
@@ -45,8 +56,18 @@
     }
 
+    /// <summary>
+    /// Removes the eventhandler from the underlying <see cref="OrConstraint"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.RemoveItemEvents"/> of base class <see cref="ViewBase"/>.
+    /// </remarks>
     protected override void RemoveItemEvents() {
       OrConstraint.Changed -= new EventHandler(OrConstraint_Changed);
       base.RemoveItemEvents();
     }
+    /// <summary>
+    /// Adds an eventhandler to the underlying <see cref="OrConstraint"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.AddItemEvents"/> of base class <see cref="ViewBase"/>.
+    /// </remarks>
     protected override void AddItemEvents() {
       base.AddItemEvents();
@@ -54,4 +75,7 @@
     }
 
+    /// <summary>
+    /// Updates all controls with the latest values.
+    /// </summary>    
     protected override void UpdateControls() {
       if (OrConstraint == null) {
Index: trunk/sources/HeuristicLab.Constraints/SubOperatorsConstraintAnalyser.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/SubOperatorsConstraintAnalyser.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/SubOperatorsConstraintAnalyser.cs	(revision 1176)
@@ -28,12 +28,24 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// Analyzes the sub-operators for specific constraints.
+  /// </summary>
   public class SubOperatorsConstraintAnalyser {
     private ICollection<IOperator> allPossibleOperators;
 
+    /// <summary>
+    /// Gets or sets all possible operators. 
+    /// </summary>
     public ICollection<IOperator> AllPossibleOperators {
       get { return allPossibleOperators; }
       set { allPossibleOperators = value; }
     }
-
+    
+    /// <summary>
+    /// Gets all operators that fulfill the expression of the constraints of the given operator. 
+    /// </summary>
+    /// <param name="op">The operator whose constraints to check.</param>
+    /// <param name="childIndex">The index of the child.</param>
+    /// <returns>All allowed operators.</returns>
     public IList<IOperator> GetAllowedOperators(IOperator op, int childIndex) {
       AndConstraint andConstraint = new AndConstraint();
@@ -109,4 +121,10 @@
     #endregion
 
+    /// <summary>
+    /// Gets all allowed operators that fulfill the expression of the given <c>AndConstraint</c>.
+    /// </summary>
+    /// <param name="constraint">The constraint that must be fulfilled.</param>
+    /// <param name="childIndex">The index of the child.</param>
+    /// <returns>All allowed operators.</returns>
     public IList<IOperator> GetAllowedOperators(AndConstraint constraint, int childIndex) {
       IList<IOperator> allowedOperators = new List<IOperator>(allPossibleOperators);
@@ -118,4 +136,10 @@
     }
 
+    /// <summary>
+    /// Gets all allowed operators that fulfill the expression of the given <c>OrConstraint</c>.
+    /// </summary>
+    /// <param name="constraint">The constraint that must be fulfilled.</param>
+    /// <param name="childIndex">The index of the child.</param>
+    /// <returns>All allowed operators.</returns>
     public IList<IOperator> GetAllowedOperators(OrConstraint constraint, int childIndex) {
       IList<IOperator> allowedOperators = new List<IOperator>();
@@ -126,12 +150,30 @@
     }
 
+    /// <summary>
+    /// Gets all allowed operators that fulfill the expression of the given <c>NotConstraint</c>.
+    /// </summary>
+    /// <param name="constraint">The constraint that must be fulfilled.</param>
+    /// <param name="childIndex">The index of the child.</param>
+    /// <returns>All allowed operators.</returns>
     public IList<IOperator> GetAllowedOperators(NotConstraint constraint, int childIndex) {
       return Substract(allPossibleOperators, GetAllowedOperators(constraint.SubConstraint, childIndex));
     }
 
+    /// <summary>
+    /// Gets all allowed operators that fulfill the expression of the given <c>AllSubOperatorsTypeConstraint</c>.
+    /// </summary>
+    /// <param name="constraint">The constraint that must be fulfilled.</param>
+    /// <param name="childIndex">The index of the child.</param>
+    /// <returns>All allowed operators.</returns>
     public IList<IOperator> GetAllowedOperators(AllSubOperatorsTypeConstraint constraint, int childIndex) {
       return Intersect(allPossibleOperators, constraint.AllowedSubOperators);
     }
 
+    /// <summary>
+    /// Gets all allowed operators that fulfill the expression of the given <c>SubOperatorTypeConstraint</c>.
+    /// </summary>
+    /// <param name="constraint">The constraint that must be fulfilled.</param>
+    /// <param name="childIndex">The index of the child.</param>
+    /// <returns>All allowed operators.</returns>
     public IList<IOperator> GetAllowedOperators(SubOperatorTypeConstraint constraint, int childIndex) {
       if (childIndex != constraint.SubOperatorIndex.Data) {
Index: trunk/sources/HeuristicLab.Constraints/SubOperatorsTypeConstraint.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/SubOperatorsTypeConstraint.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/SubOperatorsTypeConstraint.cs	(revision 1176)
@@ -29,6 +29,12 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// Constraint where the sub-operator at a specific index has to be an element of a pre-defined group.
+  /// </summary>
   public class SubOperatorTypeConstraint : ConstraintBase {
     private IntData subOperatorIndex;
+    /// <summary>
+    /// Gets the index of the sub-operator.
+    /// </summary>
     public IntData SubOperatorIndex {
       get { return subOperatorIndex; }
@@ -36,4 +42,7 @@
 
     private List<IOperator> subOperators;
+    /// <summary>
+    /// Gets all allowed sub-operators.
+    /// </summary>
     public IList<IOperator> AllowedSubOperators {
       get {
@@ -42,8 +51,12 @@
     }
 
+    ///<inheritdoc select="summary"/>
     public override string Description {
       get { return "The sub-operator at a specific index has to be an element of a pre-defined group."; }
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="SubOperatorTypeConstraint"/>.
+    /// </summary>
     public SubOperatorTypeConstraint()
       : base() {
@@ -52,4 +65,9 @@
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="SubOperatorTypeConstraint"/> with the given
+    /// <paramref name="index"/>.
+    /// </summary>
+    /// <param name="index">The index of the sub-operator.</param>
     public SubOperatorTypeConstraint(int index) : base() {
       subOperatorIndex = new IntData(index);
@@ -57,4 +75,9 @@
     }
 
+    /// <summary>
+    /// Adds the given operator to the list of sub-operators.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.FireChanged"/> of base class <see cref="ConstraintBase"/>.</remarks>
+    /// <param name="op">The operator to add.</param>
     public void AddOperator(IOperator op) {
       if(!subOperators.Contains(op)) {
@@ -64,4 +87,9 @@
     }
 
+    /// <summary>
+    /// Removes the given operator from the list of sub-operators.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.FireChanged"/> of base class <see cref="ConstraintBase"/>.</remarks>
+    /// <param name="op">The operator to remove.</param>
     public void RemoveOperator(IOperator op) {
       if(subOperators.Contains(op)) {
@@ -71,8 +99,16 @@
     }
 
+    /// <summary>
+    /// Empties the list of sub-operators.
+    /// </summary>
     public void Clear() {
       subOperators.Clear();
     }
 
+    /// <summary>
+    /// Checks whether the given element fulfills the current constraint.
+    /// </summary>
+    /// <param name="data">The item to check.</param>
+    /// <returns><c>true</c> if the constraint could be fulfilled, <c>false</c> otherwise.</returns>
     public override bool Check(IItem data) {
       IOperator op = data as IOperator;
@@ -85,4 +121,11 @@
     }
 
+    /// <summary>
+    /// Clones the current instance (deep clone).
+    /// </summary>
+    /// <remarks>Deep clone through <see cref="Auxiliary.Clone"/> method of helper class 
+    /// <see cref="Auxiliary"/>.</remarks>
+    /// <param name="clonedObjects">Dictionary of all already clone objects. (Needed to avoid cycles.)</param>
+    /// <returns>The cloned object as <see cref="SubOperatorTypeConstraint"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       SubOperatorTypeConstraint clone = new SubOperatorTypeConstraint();
@@ -95,4 +138,9 @@
     }
 
+    /// <summary>
+    /// Creates a new instance of <see cref="SubOperatorsTypeConstraintView"/> to represent the current 
+    /// instance visually.
+    /// </summary>
+    /// <returns>The created view as <see cref="SubOperatorsTypeConstraintView"/>.</returns>
     public override IView CreateView() {
       return new SubOperatorsTypeConstraintView(this);
@@ -100,4 +148,14 @@
 
     #region persistence
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>The index and the list of sub-operators are saved as child nodes with tag names 
+    /// <c>SubOperatorIndex</c> and <c>AllowedSubOperators</c>.</remarks>
+    /// <param name="name">The (tag)name of the <see cref="XmlNode"/>.</param>
+    /// <param name="document">The <see cref="XmlDocument"/> where the data is saved.</param>
+    /// <param name="persistedObjects">The dictionary of all already persisted objects. 
+    /// (Needed to avoid cycles.)</param>
+    /// <returns>The saved <see cref="XmlNode"/>.</returns>
     public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
@@ -113,4 +171,12 @@
     }
 
+    /// <summary>
+    /// Loads the persisted constraint from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>The constraint must be saved in a specific way, see <see cref="GetXmlNode"/> for 
+    /// more information.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the instance is saved.</param>
+    /// <param name="restoredObjects">The dictionary of all already restored objects. 
+    /// (Needed to avoid cycles.)</param>
     public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
       base.Populate(node, restoredObjects);
Index: trunk/sources/HeuristicLab.Constraints/SubOperatorsTypeConstraintView.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/SubOperatorsTypeConstraintView.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/SubOperatorsTypeConstraintView.cs	(revision 1176)
@@ -30,11 +30,22 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// The visual representation of a <see cref="SubOperatorTypeConstraint"/>.
+  /// </summary>
   public partial class SubOperatorsTypeConstraintView : ViewBase {
     private SubOperatorTypeConstraint constraint;
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="SubOperatorsTypeConstraintView"/>.
+    /// </summary>
     public SubOperatorsTypeConstraintView() {
       InitializeComponent();
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="SubOperatorTypeConstraint"/> with the given
+    /// <paramref name="constraint"/> to display.
+    /// </summary>
+    /// <param name="constraint">The constraint to represent visually.</param>
     public SubOperatorsTypeConstraintView(SubOperatorTypeConstraint constraint) {
       InitializeComponent();
Index: trunk/sources/HeuristicLab.Constraints/VariableComparisonConstraint.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/VariableComparisonConstraint.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/VariableComparisonConstraint.cs	(revision 1176)
@@ -28,6 +28,12 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// Constraint that compares variables in a <see cref="ConstrainedItemList"/>.
+  /// </summary>
   public class VariableComparisonConstraint : ConstraintBase {
     private StringData leftVarName;
+    /// <summary>
+    /// Gets or sets the variable name of the left item to compare.
+    /// </summary>
     public StringData LeftVarName {
       get { return leftVarName; }
@@ -36,4 +42,7 @@
 
     private StringData rightVarName;
+    /// <summary>
+    /// Gets or sets the variable name of the right item to compare.
+    /// </summary>
     public StringData RightVarName {
       get { return rightVarName; }
@@ -42,4 +51,7 @@
 
     private IntData comparer;
+    /// <summary>
+    /// Gets or sets the comparer.
+    /// </summary>
     public IntData Comparer {
       get { return comparer; }
@@ -47,4 +59,5 @@
     }
 
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get {
@@ -53,4 +66,7 @@
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="VariableComparisonConstraint"/>.
+    /// </summary>
     public VariableComparisonConstraint() {
       leftVarName = new StringData();
@@ -59,4 +75,12 @@
     }
 
+    /// <summary>
+    /// Checks whether the given element fulfills the current constraint.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown when the data is no <c>ConstrainedItemList</c>.</exception>
+    /// <exception cref="InvalidCastException">Thrown when the left varible is not of type <c>IComparable</c>.</exception>
+    /// <exception cref="InvalidOperationException">Thrown when the comparer is undefined.</exception>
+    /// <param name="data">The item to check.</param>
+    /// <returns><c>true</c> if the constraint could be fulfilled, <c>false</c> otherwise.</returns>
     public override bool Check(IItem data) {
       ConstrainedItemList list = (data as ConstrainedItemList);
@@ -92,4 +116,9 @@
     }
 
+    /// <summary>
+    /// Creates a new instance of <see cref="VariableComparisonConstraintView"/> to represent the current 
+    /// instance visually.
+    /// </summary>
+    /// <returns>The created view as <see cref="VariableComparisonConstraintView"/>.</returns>
     public override IView CreateView() {
       return new VariableComparisonConstraintView(this);
@@ -97,4 +126,11 @@
 
     #region clone & persistence
+    /// <summary>
+    /// Clones the current instance (deep clone).
+    /// </summary>
+    /// <remarks>Deep clone through <see cref="Auxiliary.Clone"/> method of helper class 
+    /// <see cref="Auxiliary"/>.</remarks>
+    /// <param name="clonedObjects">Dictionary of all already clone objects. (Needed to avoid cycles.)</param>
+    /// <returns>The cloned object as <see cref="VariableComparisonConstraint"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       VariableComparisonConstraint clone = new VariableComparisonConstraint();
@@ -106,4 +142,14 @@
     }
 
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>The variable names and the comparer are saved as child nodes with tag names
+    /// <c>LeftVarName</c>, <c>RightVarName</c> and <c>Comparer</c>.</remarks>
+    /// <param name="name">The (tag)name of the <see cref="XmlNode"/>.</param>
+    /// <param name="document">The <see cref="XmlDocument"/> where the data is saved.</param>
+    /// <param name="persistedObjects">The dictionary of all already persisted objects. 
+    /// (Needed to avoid cycles.)</param>
+    /// <returns>The saved <see cref="XmlNode"/>.</returns>
     public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
@@ -117,4 +163,12 @@
     }
 
+    /// <summary>
+    /// Loads the persisted constraint from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>The constraint must be saved in a specific way, see <see cref="GetXmlNode"/> for 
+    /// more information.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the instance is saved.</param>
+    /// <param name="restoredObjects">The dictionary of all already restored objects. 
+    /// (Needed to avoid cycles.)</param>
     public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
       base.Populate(node, restoredObjects);
Index: trunk/sources/HeuristicLab.Constraints/VariableComparisonConstraintView.cs
===================================================================
--- trunk/sources/HeuristicLab.Constraints/VariableComparisonConstraintView.cs	(revision 893)
+++ trunk/sources/HeuristicLab.Constraints/VariableComparisonConstraintView.cs	(revision 1176)
@@ -31,5 +31,13 @@
 
 namespace HeuristicLab.Constraints {
+  /// <summary>
+  /// Visual representation of a <see cref="VariableComparisonConstraint"/>.
+  /// </summary>
   public partial class VariableComparisonConstraintView : ViewBase {
+    /// <summary>
+    /// Gets or sets the VariableComparisonConstraint to represent visually.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="ViewBase"/>.
+    /// No own data storage present.</remarks>
     public VariableComparisonConstraint VariableComparisonConstraint {
       get { return (VariableComparisonConstraint)base.Item; }
@@ -37,8 +45,16 @@
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="VariableComparisonConstraintView"/>.
+    /// </summary>
     public VariableComparisonConstraintView() {
       InitializeComponent();
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="VariableComparisonConstraintView"/> with the given
+    /// <paramref name="variableComparisonConstraint"/> to display.
+    /// </summary>
+    /// <param name="variableComparisonConstraint">The constraint to represent visually.</param>
     public VariableComparisonConstraintView(VariableComparisonConstraint variableComparisonConstraint)
       : this() {
@@ -46,4 +62,9 @@
     }
 
+    /// <summary>
+    /// Removes the eventhandler from the underlying <see cref="VariableComparisonConstraint"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.RemoveItemEvents"/> of base class <see cref="ViewBase"/>.
+    /// </remarks>
     protected override void RemoveItemEvents() {
       VariableComparisonConstraint.Changed -= new EventHandler(VariableComparisonConstraint_Changed);
@@ -51,4 +72,9 @@
     }
 
+    /// <summary>
+    /// Adds an eventhandler to the underlying <see cref="VariableComparisonConstraint"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.AddItemEvents"/> of base class <see cref="ViewBase"/>.
+    /// </remarks>
     protected override void AddItemEvents() {
       base.AddItemEvents();
@@ -60,4 +86,9 @@
     }
 
+    /// <summary>
+    /// Updates all controls with the latest values.
+    /// </summary> 
+    /// <remarks>Calls <see cref="ViewBase.AddItemEvents"/> of base class <see cref="ViewBase"/>.
+    /// </remarks>
     protected override void UpdateControls() {
       base.UpdateControls();
