internal void Process(OrangeConstraintRepeaterContext context)
{
Debug.Assert(context.HasRepeaters);
_context = context;
var constraintExpressionParser = new ConstraintExpressionParser();
var expressionTemplateWithoutExpanderText = StripExpanderFrom(context.Constraint.Expression.Text);
while (context.Next())
{
var expressionText = InsertCounterValuesInto(expressionTemplateWithoutExpanderText);
var expandedConstraintExpressionResult = constraintExpressionParser.Parse(expressionText);
ProcessConstraint(expandedConstraintExpressionResult.Root);
}
}
/// <summary>
/// Parse the raw constraint expression.
/// </summary>
/// <param name="rawExpression">Raw constraint expression.</param>
internal void ParseUnit(string rawExpression)
{
if (!string.IsNullOrWhiteSpace(rawExpression))
{
var interpreter = new ConstraintExpressionParser();
var parseResult = interpreter.Parse(rawExpression);
if (parseResult.Status == ParseStatus.Success)
{
Node = parseResult.Root;
}
}
else
{
Node = null;
}
}
internal void Process(OrConstraintRepeaterContext theContext)
{
this.context = theContext;
if (!theContext.HasRepeaters)
{
ProcessSimpleConstraint(theContext.Constraint.Expression.Node);
}
else
{
var expressionTemplateWithoutExpanderText = StripExpanderFrom(theContext.Constraint.Expression.Text);
while (theContext.Next())
{
var expressionText = InsertCounterValuesInto(expressionTemplateWithoutExpanderText);
var expandedConstraintExpressionResult = new ConstraintExpressionParser().Parse(expressionText);
ProcessSimpleConstraint(expandedConstraintExpressionResult.Root);
}
}
}
private void CreateArcFrom(AllDifferentConstraintModel constraint)
{
var solverAggregateVariable = _modelSolverMap.GetSolverAggregateVariableByName(constraint.Expression.Text);
/*
* Iterate through all variables inside the aggregate and ensure
* that each variable is not equal to all variables to their
* right. The not equal operator is commutative so there is no need
* to express the constraint the other way around.
*/
for (var i = 0; i < solverAggregateVariable.Variables.Count; i++)
{
for (var z = i + 1; z < solverAggregateVariable.Variables.Count; z++)
{
var expressionText = $"${solverAggregateVariable.Name}[{i}] <> ${solverAggregateVariable.Name}[{z}]";
var interpreter = new ConstraintExpressionParser();
var parseResult = interpreter.Parse(expressionText);
Debug.Assert(parseResult.IsSuccess);
_constraintNetwork.AddArc(_arcBuilder.Build(parseResult.Root));
}
}
}
private void PopulateConstraintNetwork(ModelModel model)
{
foreach (var constraint in model.Constraints)
{
switch (constraint)
{
case ExpressionConstraintModel expressionConstraint:
CreateArcFrom(expressionConstraint);
break;
case AllDifferentConstraintModel allDifferentConstraint:
CreateArcFrom(allDifferentConstraint);
break;
default:
throw new NotImplementedException();
}
}
// 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 interpreter = new ConstraintExpressionParser();
var parseResult = interpreter.Parse(expressionText);
Debug.Assert(parseResult.IsSuccess);
_constraintNetwork.AddArc(_arcBuilder.Build(parseResult.Root));
}
}
}
}
