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));
}
