public CSP(ArrayList variables, Constraint constraints, Domain domains) 
		{
			this.variables = variables;
			//this.assignment = new Assignment(variables);
			this.domains = domains;
			this.constraints = constraints;
		}

 protected virtual void Visit(Constraint constraint)
 {
     switch (constraint.Type)
     {
         case ConstraintType.Empty:
             this.VisitEmpty(constraint as EmptyConstraint);
             break;
         case ConstraintType.Property:
             this.VisitProperty(constraint as PropertyConstraint);
             break;
         case ConstraintType.TwoPropertiesComparison:
             this.VisitTwoPropertiesComparison(constraint as TwoPropertiesConstraint);
             break;
         case ConstraintType.Sql:
             this.VisitSqlWhereConstraint(constraint as SqlWhereConstraint);
             break;
         case ConstraintType.AndOr:
             this.VisitAndOrConstraint(constraint as AndOrConstraint);
             break;
         case ConstraintType.Group:
             this.VisitGroup(constraint as ConstraintGroup);
             break;
         default:
             break;
     }
 }

 public CatKind ConstraintToCatKind(Constraint c)
 {
     if (c is ScalarVar)
     {
         return new CatTypeVar(c.ToString());
     }
     else if (c is VectorVar)
     {
         return new CatStackVar(c.ToString());
     }
     else if (c is Vector)
     {
         return CatTypeVectorFromVec(c as Vector);
     }
     else if (c is Relation)
     {
         return CatFxnTypeFromRelation(c as Relation);
     }
     else if (c is RecursiveRelation)
     {
         return new CatRecursiveType();
     }
     else if (c is Constant)
     {
         // TODO: deal with CatCustomKinds
         return new CatSimpleTypeKind(c.ToString());
     }
     else
     {
         throw new Exception("unhandled constraint " + c.ToString());
     }
 }

        /// <summary>
        /// Constructs a Posture Recognizer from a XML-File
        /// </summary>
        /// <param name="name">name of the given Posture (same as the XML-Source-File)</param>
        /// <param name="XMLPath">full path of the XML-Source-File</param>
        public GeneratedFromXMLPosture(String name, String xmlPath)
            : base(name)
        {
            try
            {
                //Load the XML-Document in a new XmlDocument-Object
                XmlDocument constraintsXML = new XmlDocument();
                constraintsXML.Load(xmlPath);

                //put Angle-Nodes from the XML to a XMLNodeList-Object
                XmlNodeList xmlConstraintsList;
                XmlNode root = constraintsXML.DocumentElement;
                xmlConstraintsList = root.SelectNodes("//posture/constraints/angle");

                //xmlConstraintsList -> constraints
                foreach (XmlNode newConstraint in xmlConstraintsList)
                {
                    Constraint newOne = new Constraint();

                    newOne.JointA = newConstraint.ChildNodes[0].InnerText;
                    newOne.JointB = newConstraint.ChildNodes[1].InnerText;
                    newOne.JointC = newConstraint.ChildNodes[2].InnerText;
                    newOne.min = Convert.ToInt16(newConstraint.ChildNodes[3].InnerText);
                    newOne.max = Convert.ToInt16(newConstraint.ChildNodes[4].InnerText);

                    constraints.Add(newOne);
                }

            }
            catch (Exception e)
            {
                Console.WriteLine("Sorry, could not read " + xmlPath + ". StackTrace following." + e.StackTrace);
            }
        }

 public void No_PrimaryKey()
 {
     var c = new Constraint("ix_testing", ContraintType.Index, "testing");
     var test = new Table("test");
     test.Constraints.Add(c);
     Assert.Null(test.PrimaryKey);
 }

 public Column(string name, DataType type, Constraint constraint, bool primaryKey)
 {
     Name = name;
     Type = type;
     Constraint = constraint;
     PrimaryKey = primaryKey;
 }

 public void Set_PrimaryKey()
 {
     var c = new Constraint("ix_testing", ContraintType.PrimaryKey, "testing");
     var test = new Table("test");
     test.Constraints.Add(c);
     Assert.Equal(c, test.PrimaryKey);
 }

        internal void Create(int numConstraints)
        {
            Vector = new Constraint[numConstraints];

            // Initialize this to out of range.
            firstActiveConstraintIndex = numConstraints;
        }

 public void GetSet_Unique()
 {
     var test = new Constraint("test", ContraintType.Constraint, new List<string>());
     var c = test.Unique;
     test.Unique = !c;
     Assert.Equal(!c, test.Unique);
 }

        public Constraint CombineConstraint(Constraint other, System.Linq.Expressions.ExpressionType op)
        {
            BooleanCombinationConstraint combinedConstraint = new BooleanCombinationConstraint(op);

            combinedConstraint.AddConstraint(this);
            combinedConstraint.AddConstraint(other);

            return combinedConstraint;
        }

        /// <summary>
        /// Constructs an AttributeConstraint for a specified attriute
        /// Type and base constraint.
        /// </summary>
        /// <param name="type"></param>
        /// <param name="baseConstraint"></param>
        public AttributeConstraint(Type type, Constraint baseConstraint)
            : base(baseConstraint)
        {
            this.expectedType = type;

            if (!typeof(Attribute).IsAssignableFrom(expectedType))
                throw new ArgumentException(string.Format(
                    "Type {0} is not an attribute", expectedType), "type");
        }

 public static void IsValid(
     Constraint obj,
     MethodReturnEventArgs<bool> e,
     object constrainedObjectParam,
     object constrainedValueParam)
 {
     // the base constraint accepts all values
     e.Result = true;
 }

		public void ShowPopup(View popupView, Constraint xConstraint, Constraint yConstraint, Constraint widthConstraint = null, Constraint heightConstraint = null)
		{
			DismissPopup();
			_popup = popupView;

			_content.InputTransparent = true;
			Children.Add(_popup, xConstraint, yConstraint, widthConstraint, heightConstraint);

			UpdateChildrenLayout();
		}

        public override VersionRangePart Intersects(Constraint constraint)
        {
            #region Sanity checks
            if (constraint == null) throw new ArgumentNullException("constraint");
            #endregion

            // If the exact version lies within the constraint, the exact version remains
            if (constraint.NotBefore != null && _version < constraint.NotBefore) return null;
            if (constraint.Before != null && _version >= constraint.Before) return null;
            return this;
        }

 public static SubSpace FromPoint(params double[] coordinates)
 {
     //foreach coordinate, one constraint x[i]=coordinate[y], and the term??
     Constraint[] constraints=new Constraint[coordinates.Length];
     for (int i = 0; i < coordinates.Length; i++)
     {
         double[] constraintCoeffs=new double[coordinates.Length];
         constraintCoeffs[i] = coordinates[i];
         constraints[i] = new DefaultConstraint(constraintCoeffs);
     }
     return new SubSpace(constraints);
 }

        public void CanIgnoreTable()
        {
            var db = new Database();
            var table = new Table("dbo", "IgnoredTableWithConstraints");
            var constraint = new Constraint("TestConstraint", "", "");
            table.Constraints.Add(constraint);
            db.DataTables.Add(table);

            db.Ignore(new[] { "IgnoredTableWithConstraints" });

            db.Tables.Any().Should().BeFalse();
        }

        private void SwapConstraint(Constraint constraint)
        {
            // Swap out the constraint at the current active/inactive border index (which has been updated
            // according to the direction we're moving it).
            Constraint swapConstraint = Vector[firstActiveConstraintIndex];
            swapConstraint.SetVectorIndex(constraint.VectorIndex);
            Vector[constraint.VectorIndex] = swapConstraint;

            // Toggle the state of the constraint being updated.
            Vector[firstActiveConstraintIndex] = constraint;
            constraint.SetActiveState(!constraint.IsActive, firstActiveConstraintIndex);
        }

        internal DfDvNode Set(DfDvNode parent, Constraint constraintToEval, Variable variableToEval, Variable variableDoneEval)
        {
            this.Parent = parent;
            this.ConstraintToEval = constraintToEval;
            this.VariableToEval = variableToEval;
            this.VariableDoneEval = variableDoneEval;
            this.Depth = 0;
            this.ChildrenHaveBeenPushed = false;

            constraintToEval.Lagrangian = 0.0;
            return this;
        }

        internal void DeactivateConstraint(Constraint constraint)
        {
            Debug.Assert(constraint.IsActive, "Constraint is not active");

            // Swap it from the active region to the end of the inactive region of the Vector.
            Debug.Assert(firstActiveConstraintIndex < Vector.Length, "All constraints are already inactive");
            Debug.Assert(Vector[firstActiveConstraintIndex].IsActive, "Constraint in active region is not active");

            SwapConstraint(constraint);
            ++firstActiveConstraintIndex;

            //Debug_AssertConsistency();
        }

        internal void ActivateConstraint(Constraint constraint)
        {
            Debug.Assert(!constraint.IsActive, "Constraint is already active");

            // Swap it from the inactive region to the start of the active region of the Vector.
            Debug.Assert(firstActiveConstraintIndex > 0, "All constraints are already active");
            --firstActiveConstraintIndex;
            Debug.Assert(!Vector[firstActiveConstraintIndex].IsActive, "Constraint in inactive region is active");

            SwapConstraint(constraint);

            //Debug_AssertConsistency();
        }