private void ReadSingletonVariable(XmlNode variableNode)
{
var variableIdAttribute = variableNode.Attributes["id"];
var variableId = variableIdAttribute.Value;
var variableName = string.Empty;
var domainExpression = string.Empty;
for (var i = 0; i < variableNode.ChildNodes.Count; i++)
{
var childNode = variableNode.ChildNodes[i];
switch (childNode.Name)
{
case "name":
variableName = childNode.InnerText;
break;
case "domain":
domainExpression = childNode.InnerText;
break;
}
}
var variableModel = new SingletonVariableModel(_model, new ModelName(variableName), new InlineDomainModel(domainExpression));
variableModel.Id = Convert.ToInt32(variableId);
_model.AddVariable(variableModel);
}
public SingletonVariableModelItemViewModel(SingletonVariableModel theSingletonVariableModel, IWindowManager theWindowManager, IEventAggregator theEventAggregator)
: base(theSingletonVariableModel)
{
Validator = new SingletonVariableModelItemViewModelValidator();
SingletonVariable = theSingletonVariableModel;
_windowManager = theWindowManager;
_eventAggregator = theEventAggregator;
}
public SingletonVariableModelItemViewModel MapFrom(SingletonVariableModel theVariableModel)
{
Debug.Assert(theVariableModel.HasIdentity);
var variableViewModel = new SingletonVariableModelItemViewModel(theVariableModel, _windowManager, _eventAggregator);
return(variableViewModel);
}
/// <summary>
/// Add a singleton variable.
/// </summary>
/// <param name="theVariableName">Variable name.</param>
/// <param name="theDomainExpression">Variable domain.</param>
/// <returns>Workspace context.</returns>
public WorkspaceBuilder AddSingleton(string theVariableName, string theDomainExpression)
{
if (string.IsNullOrWhiteSpace(theVariableName))
{
throw new ArgumentException(nameof(theVariableName));
}
if (string.IsNullOrWhiteSpace(theDomainExpression))
{
throw new ArgumentException(nameof(theDomainExpression));
}
var newVariable = new SingletonVariableModel(_model, new ModelName(theVariableName), new InlineDomainModel(theDomainExpression));
_model.AddVariable(newVariable);
return(this);
}
private void WriteVariable(SingletonVariableModel aVariable, XmlElement variablesRoot)
{
var variableElement = Document.CreateElement("singleton-variable");
var idAttribute = Document.CreateAttribute("id");
idAttribute.Value = Convert.ToString(aVariable.Id);
variableElement.Attributes.Append(idAttribute);
var nameElement = Document.CreateElement("name");
var encodedNameNode = Document.CreateCDataSection(aVariable.Name);
nameElement.AppendChild(encodedNameNode);
variableElement.AppendChild(nameElement);
var domainElement = Document.CreateElement("domain");
var encodedDomainNode = Document.CreateCDataSection(aVariable.DomainExpression.Text);
domainElement.AppendChild(encodedDomainNode);
variableElement.AppendChild(domainElement);
variablesRoot.AppendChild(variableElement);
}
internal void AddVariableDomainValue(SingletonVariableModel theSingleton, DomainValue theVariableBand)
{
this.valueVariableDictionary.Add(theSingleton.Name.Text, theVariableBand);
}
/// <summary>
/// Initialize a new singleton variable added message with the new variable.
/// </summary>
/// <param name="theNewVariable">New variable.</param>
public SingletonVariableAddedMessage(SingletonVariableModel theNewVariable)
{
NewVariable = theNewVariable;
}
private object ConvertSolverValueToModel(SingletonVariableModel theVariable, long solverValue)
{
var variableDomainValue = this.valueMapper.GetDomainValueFor(theVariable);
return(variableDomainValue.MapFrom(solverValue));
}
private SolverVariable CreateIntegerVariableFrom(SingletonVariableModel singletonVariable)
{
return(new SolverVariable(singletonVariable.Name, CreateRangeFrom(singletonVariable)));
}
internal OrangeSingletonVariableMap(SingletonVariableModel modelVariable, SolverVariable solverVariable)
{
SolverVariable = solverVariable;
ModelVariable = modelVariable;
}
public void InitializeVariableWithInlineRawExpressionWoutWhitespace()
{
var sut = new SingletonVariableModel(CreateModel(), new ModelName("x"), new InlineDomainModel("1..10"));
Assert.That(sut.DomainExpression.InlineDomain, Is.InstanceOf <RangeDomainExpressionNode>());
}
public void InitializeVariableWithDomainReferenceRawExpressionWoutWhitespace()
{
var sut = new SingletonVariableModel(CreateModel(), new ModelName("x"), new InlineDomainModel("$A"));
Assert.That(sut.DomainExpression.DomainReference.DomainName.Name, Is.EqualTo("A"));
}
public void InitializeVariableWithEmptyExpressionWoutWhitespace()
{
var sut = new SingletonVariableModel(CreateModel(), new ModelName("x"), new InlineDomainModel());
Assert.That(sut.DomainExpression.IsEmpty, Is.True);
}
public void InitializeVariableWithValidNameSetsExpectedNameInVariable()
{
var sut = new SingletonVariableModel(CreateModel(), new ModelName("x"));
Assert.That(sut.Name, Is.EqualTo(new ModelName("x")));
}
internal OrSingletonVariableMap(SingletonVariableModel modelVariable, IntVar solverVariable)
{
SolverVariable = solverVariable;
ModelVariable = modelVariable;
}
internal void Add(SingletonVariableModel singletonVariable, SolverVariable solverVariable)
{
_variableMap.Add(new OrangeSingletonVariableMap(singletonVariable, solverVariable));
}
private static string CreateOrToolsVariableNameFrom(BucketVariableModel bucket, int index, SingletonVariableModel singletonVariable)
{
return(bucket.Name + "_" + Convert.ToString(index) + "_" + singletonVariable.Name);
}
internal void Add(SingletonVariableModel singletonVariable, IntVar orVariable)
{
_variableMap.Add(new OrSingletonVariableMap(singletonVariable, orVariable));
}