public void InitializeWithRawExpressionParsesExpectedAggregateVariableNameOnRight() { var sut = new ExpressionConstraintModel(new ModelModel(), new ConstraintExpressionModel("$x[1] > $x[2]")); var rightVariableReference = (AggregateVariableReferenceNode)sut.Expression.Node.InnerExpression.RightExpression.InnerExpression; Assert.That(rightVariableReference.VariableName, Is.EqualTo("x")); }
public void Initialize_With_Raw_Expression_Parses_Expected_Variable_Name_On_Left() { var sut = new ExpressionConstraintModel(WorkspaceModelFactory.Create().Model, new ConstraintExpressionModel("$x > 1")); var leftVariableReference = (SingletonVariableReferenceNode)sut.Expression.Node.InnerExpression.LeftExpression.InnerExpression; Assert.That(leftVariableReference.VariableName, Is.EqualTo("x")); }
public void InitializeWithRawExpressionParsesExpectedAggregateVariableSubscriptOnLeft() { var sut = new ExpressionConstraintModel(new ModelModel(), new ConstraintExpressionModel("$xx[1] > 1")); var leftVariableReference = (AggregateVariableReferenceNode)sut.Expression.Node.InnerExpression.LeftExpression.InnerExpression; Assert.That(leftVariableReference.SubscriptStatement.Subscript, Is.EqualTo(1)); }
private void ReadExpressionConstraint(XmlNode constraintNode) { var constraintIdAttribute = constraintNode.Attributes["id"]; var constraintId = constraintIdAttribute.Value; var constraintName = string.Empty; var expression = string.Empty; for (var i = 0; i < constraintNode.ChildNodes.Count; i++) { var childNode = constraintNode.ChildNodes[i]; switch (childNode.Name) { case "name": constraintName = childNode.InnerText; break; case "expression": expression = childNode.InnerText; break; } } var constraintModel = new ExpressionConstraintModel(_model, new ModelName(constraintName), new ConstraintExpressionModel(expression)); constraintModel.Id = Convert.ToInt32(constraintId); _model.AddConstraint(constraintModel); }
public void InitializeWithRawExpressionParsesExpectedAggregateVariableNameOnLeft() { var sut = new ExpressionConstraintModel(WorkspaceModelFactory.Create().Model, new ConstraintExpressionModel("$xx[1] > 1")); var leftVariableReference = (AggregateVariableReferenceNode)sut.Expression.Node.InnerExpression.LeftExpression.InnerExpression; Assert.That(leftVariableReference.VariableName, Is.EqualTo("xx")); }
public void Initialize_With_Raw_Expression_Parses_Expected_Variable_Name_On_Right() { var sut = new ExpressionConstraintModel(new ModelModel(), new ConstraintExpressionModel("$y = $x")); var rightVariableReference = (SingletonVariableReferenceNode)sut.Expression.Node.InnerExpression.RightExpression.InnerExpression; Assert.That(rightVariableReference.VariableName, Is.EqualTo("x")); }
public void Initialize_With_Raw_Expression_Parses_Expected_Literal_On_Right() { var sut = new ExpressionConstraintModel(new ModelModel(), new ConstraintExpressionModel("$y <= 44")); var rightLiteral = (IntegerLiteralNode)sut.Expression.Node.InnerExpression.RightExpression.InnerExpression; Assert.That(rightLiteral.Value, Is.EqualTo(44)); }
public ExpressionConstraintModelItemViewModel(ExpressionConstraintModel theExpressionConstraint, IWindowManager theWindowManager) : base(theExpressionConstraint) { Validator = new ExpressionConstraintModelItemViewModelValidator(); ExpressionText = theExpressionConstraint.Expression.Text; ExpressionConstraint = theExpressionConstraint; _windowManager = theWindowManager; }
/// <summary> /// Initialize a repeater context from the constraint. /// </summary> /// <param name="theConstraint">Expression constraint.</param> /// <param name="theModel">Model</param> public OrConstraintRepeaterContext(ExpressionConstraintModel theConstraint, ModelModel theModel) { Constraint = theConstraint; Model = theModel; this.counters = new List <CounterContext>(); if (!theConstraint.Expression.Node.HasExpander) { return; } CreateCounterContextsFrom(theConstraint.Expression.Node.Expander); }
/// <summary> /// Initialize a repeater context from the constraint. /// </summary> /// <param name="theConstraint">Expression constraint.</param> internal OrangeConstraintRepeaterContext(ExpressionConstraintModel theConstraint) { Constraint = theConstraint; Bundle = theConstraint.Parent; this.counters = new List <CounterContext>(); if (!theConstraint.Expression.Node.HasExpander) { return; } CreateCounterContextsFrom(theConstraint.Expression.Node.Expander); }
public WorkspaceBuilder WithConstraintExpression(string theConstraintExpression) { if (string.IsNullOrWhiteSpace(theConstraintExpression)) { throw new ArgumentException(nameof(theConstraintExpression)); } var constraintModel = new ExpressionConstraintModel(_model, new ConstraintExpressionModel(theConstraintExpression)); _model.AddConstraint(constraintModel); return(this); }
private void CreateArcFrom(ExpressionConstraintModel constraint) { if (constraint.Expression.Node.HasExpander) { // Process the constraint repeater adding arcs as necessary var repeater = new OrangeConstraintRepeater(_constraintNetwork, _modelSolverMap, constraint.Parent, _valueMapper); repeater.Process(repeater.CreateContextFrom(constraint)); } else { _constraintNetwork.AddArc(_arcBuilder.Build(constraint.Expression.Node)); } }
private void WriteConstraint(ExpressionConstraintModel expressionConstraint, XmlElement constraintsRoot) { var expressionConstraintElement = Document.CreateElement("expression-constraint"); var idAttribute = Document.CreateAttribute("id"); idAttribute.Value = Convert.ToString(expressionConstraint.Id); expressionConstraintElement.Attributes.Append(idAttribute); var nameElement = Document.CreateElement("name"); var encodedNameNode = Document.CreateCDataSection(expressionConstraint.Name); nameElement.AppendChild(encodedNameNode); expressionConstraintElement.AppendChild(nameElement); var expressionElement = Document.CreateElement("expression"); var encodedExpressionNode = Document.CreateCDataSection(expressionConstraint.Expression.Text); expressionElement.AppendChild(encodedExpressionNode); expressionConstraintElement.AppendChild(expressionElement); constraintsRoot.AppendChild(expressionConstraintElement); }
/// <summary> /// Process the constraints from the model. /// </summary> /// <param name="model">The model.</param> internal void ProcessConstraints(ModelModel model) { foreach (var constraint in model.Constraints) { switch (constraint) { case ExpressionConstraintModel expressionConstraint: var expressionConstraintConverter = new OrExpressionConstraintConverter(this.solver, this.cache, model, this.valueMapper); expressionConstraintConverter.ProcessConstraint(expressionConstraint); break; case AllDifferentConstraintModel allDifferentConstraint: var allDifferentConstraintConverter = new OrAllDifferentConstraintConverter(this.solver, this.cache, model); allDifferentConstraintConverter.ProcessConstraint(allDifferentConstraint); break; default: throw new NotImplementedException("Unknown constraint."); } } // Constraints inside bundles must be processed after the bucket maps have been created foreach (var bucket in model.Buckets) { foreach (var allDifferentConstraint in bucket.Bundle.AllDifferentConstraints) { var variableNames = new List <string>(ExtractVariablesFrom(allDifferentConstraint.Expression.Text)); for (var bundleCounter = 0; bundleCounter < bucket.Size; bundleCounter++) { var bucketName = bucket.Name.Text; var expressionText = $"%{bucketName}[{bundleCounter}].{variableNames[0]} <> %{bucketName}[{bundleCounter}].{variableNames[1]}"; var expressionConstraint = new ExpressionConstraintModel(model, new ConstraintExpressionModel(expressionText)); var expressionConstraintConverter = new OrExpressionConstraintConverter(this.solver, this.cache, model, this.valueMapper); expressionConstraintConverter.ProcessConstraint(expressionConstraint); } } } }
internal OrangeConstraintRepeaterContext CreateContextFrom(ExpressionConstraintModel constraint) { return(new OrangeConstraintRepeaterContext(constraint)); }
public void Initialize_With_Raw_Expression_Parses_Expected_Operator() { var sut = new ExpressionConstraintModel(new ModelModel(), new ConstraintExpressionModel(" $a1 > 999 ")); Assert.That(sut.Expression.OperatorType, Is.EqualTo(OperatorType.Greater)); }
/// <summary> /// Map the expression constraint model into the or-tools solver. /// </summary> /// <param name="constraint">Expression constraint model.</param> internal void ProcessConstraint(ExpressionConstraintModel constraint) { var repeater = new OrConstraintRepeater(this.solver, this.cache, this.model, this.valueMapper); repeater.Process(repeater.CreateContextFrom(constraint)); }