public VisualizerUpdateContext(SolutionSnapshot theSnapshot, DisplayModel theDisplay, VisualizerBindingExpressionModel theBinding, ModelModel theModel)
{
Snapshot = theSnapshot;
Display = theDisplay;
Binding = theBinding;
Model = theModel;
}
/// <summary>
/// Initialize the solution with the model and snapshot.
/// </summary>
/// <param name="theModel">Model that the solution is supposed to solve.</param>
/// <param name="theSnapshot">Solution snapshot.</param>
/// <param name="duration">Time taken to find the solution.</param>
public SolutionModel(ModelModel theModel, SolutionSnapshot theSnapshot, TimeSpan duration)
{
Model = theModel;
Snapshot = theSnapshot;
Snapshot = new SolutionSnapshot();
Duration = duration;
}
/// <summary>
/// Initialize a workspace with a model.
/// </summary>
public WorkspaceModel(ModelModel theModel)
{
Model = theModel;
Model.Workspace = this;
Solution = new SolutionModel(Model);
Display = new DisplayModel(Model);
}
/// <summary>
/// Validate the constraint expression.
/// </summary>
/// <param name="theModel">Model to validate.</param>
/// <param name="theContext">Validation context to capture the errors.</param>
/// <returns>
/// Return true if the constraint is valid, return false if
/// the constraint is not valid.
/// </returns>
public override bool Validate(ModelModel theModel, ModelValidationContext theContext)
{
if (Expression.Node == null)
{
return(false);
}
var variableCaptureVisitor = new ConstraintVariableReferenceCaptureVisitor();
Expression.Node.AcceptVisitor(variableCaptureVisitor);
var variableReferences = variableCaptureVisitor.GetReferences();
foreach (var singletonVariableReference in variableReferences.SingletonVariableReferences)
{
if (theModel.Variables.FirstOrDefault(_ => _.Name.IsEqualTo(singletonVariableReference.VariableName)) == null)
{
theContext.AddError($"Missing singleton variable {singletonVariableReference.VariableName}");
return(false);
}
}
foreach (var aggregateVariableReference in variableReferences.AggregateVariableReferences)
{
if (theModel.Aggregates.FirstOrDefault(_ => _.Name.IsEqualTo(aggregateVariableReference.VariableName)) == null)
{
theContext.AddError($"Missing aggregate variable {aggregateVariableReference.VariableName}");
return(false);
}
}
return(true);
}
/// <summary>
/// Initialize a workspace with default values.
/// </summary>
public WorkspaceModel()
{
Model = new ModelModel(this);
Model.Workspace = this;
Solution = new SolutionModel(Model);
Display = new DisplayModel(Model);
}
/// <summary>
/// Initialize a variable with a variable name.
/// </summary>
public SingletonVariableModel(ModelModel theModel, ModelName variableName)
: base(theModel.Workspace, variableName, new InlineDomainModel())
{
}
public AllDifferentConstraintModel(ModelModel theModel)
{
Parent = theModel;
Expression = new AllDifferentConstraintExpressionModel();
}
public AllDifferentConstraintModel(ModelModel theModel, ModelName theName, AllDifferentConstraintExpressionModel theExpressionModel)
: base(theName)
{
Parent = theModel;
Expression = theExpressionModel;
}
/// <summary>
/// Initializes a variable with a variable name.
/// </summary>
protected VariableModel(ModelModel theModel, ModelName variableName)
: base(variableName)
{
Parent = theModel;
DomainExpression = new VariableDomainExpressionModel();
}
/// <summary>
/// Initialize a display model with default values.
/// </summary>
/// <param name="theModel"></param>
public DisplayModel(ModelModel theModel)
{
Visualizers = new List <VisualizerModel>();
this.bindings = new List <VisualizerBindingExpressionModel>();
this.model = theModel;
}
/// <summary>
/// Validate the constraint.
/// </summary>
/// <returns>
/// Return true if the constraint is valid, return false if
/// the constraint is not valid.
/// </returns>
public virtual bool Validate(ModelModel theModel)
{
return(Validate(theModel, new ModelValidationContext()));
}
public ExpressionConstraintModel(ModelModel theModel, ConstraintExpressionModel theExpression)
: base(new ModelName())
{
Parent = theModel;
this.expression = theExpression;
}
public ExpressionConstraintModel(ModelModel theModel, ModelName theName)
: base(theName)
{
Parent = theModel;
this.expression = new ConstraintExpressionModel();
}
/// <summary>
/// Initialize a shared domain with a name and domain expression.
/// </summary>
public SharedDomainModel(ModelModel theModel, ModelName theName, SharedDomainExpressionModel theExpression)
: base(theName)
{
Parent = theModel;
_expression = theExpression;
}
/// <summary> /// Validate the constraint placing errors into the validation context. /// </summary> /// <returns> /// Return true if the constraint is valid, return false if /// the constraint is not valid. /// </returns> public abstract bool Validate(ModelModel theModel, ModelValidationContext theContext);
/// <summary>
/// Initialize the solution with the model.
/// </summary>
/// <param name="theModel">Model that the solution is supposed to solve.</param>
public SolutionModel(ModelModel theModel)
{
Model = theModel;
Snapshot = new SolutionSnapshot();
Snapshot = new SolutionSnapshot();
}
public PropertyUpdateContext(SolutionSnapshot theSnapshot, DisplayModel theDisplay, ModelModel theModel)
{
Snapshot = theSnapshot;
Display = theDisplay;
Model = theModel;
}