/// <summary>Compares two objects and returns a value indicating whether one is less than, equal to, or greater than the other.</summary>
/// <param name="x">The first object to compare.</param>
/// <param name="y">The second object to compare.</param>
/// <returns>A signed integer that indicates the relative values of <paramref name="x" /> and <paramref name="y" />, as shown in the following table.
/// Value
/// Meaning
/// Less than zero
/// <paramref name="x" /> is less than <paramref name="y" />.
/// Zero
/// <paramref name="x" /> equals <paramref name="y" />.
/// Greater than zero
/// <paramref name="x" /> is greater than <paramref name="y" />.</returns>
public int Compare(ValueArray <string> x, ValueArray <string> y)
{
var valueX = this.GetValue(x);
var valueY = this.GetValue(y);
return(valueX.CompareTo(valueY));
}
internal ValueArray[,] reduce(ValueArray[,] results, List <string> line)
{
var header_col = headerDict[line.Skip(skipCols).Take(headerKeys)];
var row_keys = line.Take(skipCols);
var curr_values = new string[valueCount];
for (int i = 0; i < valueCount; i++)
{
curr_values[i] = line[skipCols + headerKeys + i];
}
if (rowDict.ContainsKey(row_keys))
{
results[rowDict[row_keys], skipCols + header_col] = new ValueArray();
results[rowDict[row_keys], skipCols + header_col].row_keys = row_keys;
results[rowDict[row_keys], skipCols + header_col].values = curr_values;
}
else
{
rowDict.Add(row_keys, currentLine);
results[currentLine, skipCols + header_col] = new ValueArray();
results[currentLine, skipCols + header_col].row_keys = row_keys;
results[currentLine, skipCols + header_col].values = curr_values;
currentLine++;
}
return(results);
}
public override void DoRows(Parse theRows) {
if (theRows == null) throw new TableStructureException("No header row.");
ExamineTableStructure(theRows.Parts);
if (expectedCount == 0) return;
myValues = new ValueArray(RepeatString);
base.DoRows(theRows.More);
}
protected virtual bool OnNewWindowPolicyDecisionRequested(WebFrame frame, NetworkRequest request, WebNavigationAction action, WebPolicyDecision decision)
{
var val = new Value(GType.Int);
var valueArray = new ValueArray(5u);
var array = new Value[5];
array [0] = new Value(this);
valueArray.Append(array [0]);
array [1] = new Value(frame);
valueArray.Append(array [1]);
array [2] = new Value(request);
valueArray.Append(array [2]);
array [3] = new Value(action);
valueArray.Append(array [3]);
array [4] = new Value(decision);
valueArray.Append(array [4]);
GLib.Object.g_signal_chain_from_overridden(valueArray.ArrayPtr, ref val);
var array2 = array;
for (int i = 0; i < array2.Length; i++)
{
var value = array2 [i];
value.Dispose();
}
bool result = (bool)val;
val.Dispose();
return(result);
}
public void VerifyExecuteCreateSubscriptionCommand()
{
var vm = new ProductTreeViewModel(this.option, this.session.Object, this.thingDialogNavigationService.Object, this.panelNavigationService.Object, null, null);
var revisionNumber = typeof(Iteration).GetProperty("RevisionNumber");
revisionNumber.SetValue(this.iteration, 50);
var elementdef = new ElementDefinition(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
Container = this.iteration
};
var anotherDomain = new DomainOfExpertise(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
Name = "Not owned"
};
var boolParamType = new BooleanParameterType(Guid.NewGuid(), this.assembler.Cache, this.uri);
var parameter = new Parameter(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
Owner = anotherDomain, Container = elementdef, ParameterType = boolParamType
};
var published = new ValueArray <string>(new List <string> {
"published"
});
var paramValueSet = new ParameterValueSet(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
Published = published,
Manual = published,
Computed = published,
ValueSwitch = ParameterSwitchKind.COMPUTED
};
parameter.ValueSet.Add(paramValueSet);
elementdef.Parameter.Add(parameter);
this.iteration.TopElement = elementdef;
CDPMessageBus.Current.SendObjectChangeEvent(this.iteration, EventKind.Updated);
Assert.AreSame(elementdef, vm.TopElement.Single().Thing);
Assert.AreEqual(1, vm.TopElement.Single().ContainedRows.Count);
var paramRow = vm.TopElement.Single().ContainedRows.First() as ParameterOrOverrideBaseRowViewModel;
Assert.NotNull(paramRow);
vm.SelectedThing = paramRow;
Assert.IsTrue(vm.CreateSubscriptionCommand.CanExecute(null));
Assert.AreEqual(0, paramRow.Thing.ParameterSubscription.Count);
vm.SelectedThing = null;
vm.CreateSubscriptionCommand.Execute(null);
this.session.Verify(x => x.Write(It.IsAny <OperationContainer>()), Times.Never);
vm.SelectedThing = vm.TopElement.Single();
vm.CreateSubscriptionCommand.Execute(null);
this.session.Verify(x => x.Write(It.IsAny <OperationContainer>()), Times.Never);
vm.SelectedThing = paramRow;
vm.CreateSubscriptionCommand.Execute(null);
this.session.Verify(x => x.Write(It.IsAny <OperationContainer>()), Times.Exactly(1));
}
private void ConfirmSeed()
{
try
{
ConfirmSeedCommand.Executable = false;
var decodedSeed = WalletSeed.DecodeAndValidateUserInput(Input, _pgpWordList);
if (ValueArray.ShallowEquals(_seed, decodedSeed))
{
_wizard.CurrentDialog = new PromptPassphrasesDialog(Wizard, _seed);
}
else
{
MessageBox.Show("Seed does not match");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Invalid seed");
}
finally
{
ConfirmSeedCommand.Executable = true;
}
}
// Returns the number of methods newly added to the dictionary.
private bool AddMethodsOverwriteExisting(
MemberInfo /*!*/[] /*!*/ newOverloads, RubyMethodGroupInfo /*!*/[] overloadOwners)
{
bool anyChange = false;
for (int i = 0; i < newOverloads.Length; i++)
{
var method = (MethodBase)newOverloads[i];
if (IsVisible(method))
{
var paramTypes = new ValueArray <Type>(ReflectionUtils.GetParameterTypes(method.GetParameters()));
if (_allMethods == null)
{
_allMethods = new Dictionary <ValueArray <Type>, ClrOverloadInfo>();
}
_allMethods[paramTypes] = new ClrOverloadInfo {
Overload = method,
Owner = (overloadOwners != null) ? overloadOwners[i] : null
};
anyChange = true;
}
}
return(anyChange);
}
/// <summary>
/// Set a ValueSet for a compound ParameterType with 2 components
/// </summary>
/// <param name="valueset">The <see cref="ParameterValueSetBase"/> to set</param>
private void SetCompoundValueSet(ParameterValueSetBase valueset)
{
var manualSet = new ValueArray <string>(new List <string> {
"manual1", "manual2"
});
var referenceSet = new ValueArray <string>(new List <string> {
"ref1", "ref2"
});
var computedSet = new ValueArray <string>(new List <string> {
"computed1", "computed2"
});
var publishedSet = new ValueArray <string>(new List <string> {
"published1", "published2"
});
var formulaSet = new ValueArray <string>(new List <string> {
"formula1", "formula2"
});
valueset.Manual = manualSet;
valueset.Reference = referenceSet;
valueset.Computed = computedSet;
valueset.Published = publishedSet;
valueset.Formula = formulaSet;
valueset.ValueSwitch = ParameterSwitchKind.REFERENCE;
}
public void InsertWorks()
{
var arr = new ValueArray <int>(5);
for (int i = 0; i < 5; i++)
{
arr[i] = i + 1;
}
Assert.Equal(1, arr[0]);
arr.Insert(0, 99);
Assert.Equal(99, arr[0]);
Assert.Equal(1, arr[1]);
Assert.Equal(2, arr[2]);
Assert.Equal(6, arr.Count);
arr.Insert(1, 28);
Assert.Equal(99, arr[0]);
Assert.Equal(28, arr[1]);
Assert.Equal(1, arr[2]);
Assert.Equal(7, arr.Count);
arr.Insert(7, 100);
Assert.Equal(8, arr.Count);
Assert.Equal(100, arr[7]);
}
public void VerifyThatGetPathWorks()
{
// **************************INPUT***************************************
var published = new ValueArray <string>(new List <string> {
"manual1", "manual2"
}, this.valueset);
var actual = new ValueArray <string>(new List <string> {
"manual1", "manual2"
}, this.valueset);
this.valueset.Published = published;
this.valueset.Manual = actual;
this.valueset.ValueSwitch = ParameterSwitchKind.MANUAL;
this.valueset.ActualOption = this.option;
var compoundtype = new CompoundParameterType(Guid.NewGuid(), null, this.uri);
var component1 = new ParameterTypeComponent(Guid.NewGuid(), null, this.uri)
{
ParameterType = this.parameterType1,
ShortName = "c1"
};
var component2 = new ParameterTypeComponent(Guid.NewGuid(), null, this.uri)
{
ParameterType = this.parameterType1,
ShortName = "c2"
};
compoundtype.Component.Add(component1);
compoundtype.Component.Add(component2);
var state2 = new ActualFiniteState(Guid.NewGuid(), null, this.uri);
this.stateList.ActualState.Add(state2);
this.parameter1.ParameterType = compoundtype;
this.parameter1.ValueSet.Add(this.valueset);
this.parameter1.IsOptionDependent = true;
var valueset2 = new ParameterValueSet(Guid.NewGuid(), null, this.uri)
{
ActualState = state2,
Published = published
};
this.parameter1.ValueSet.Add(valueset2);
var row = new ParameterRowViewModel(this.parameter1, this.option, this.session.Object, null);
Assert.AreEqual(this.nestedParameterPath, row.GetPath());
var row2 = new ParameterTypeComponentRowViewModel(compoundtype.Component.First(), this.session.Object, null);
Assert.AreEqual(string.Empty, row2.GetPath());
var row3 = new ParameterTypeComponentRowViewModel(compoundtype.Component.First(), this.session.Object, row);
Assert.AreEqual(this.nestedParameterPath, row3.GetPath());
}
public void VerifyThatPropertiesArePopulatedForScalarPropertiesWithOption()
{
// **********************************************************************
var published = new ValueArray <string>(new List <string> {
"manual"
}, this.valueset);
var actual = new ValueArray <string>(new List <string> {
"manual"
}, this.valueset);
this.valueset.Published = published;
this.valueset.Manual = actual;
this.valueset.ValueSwitch = ParameterSwitchKind.MANUAL;
this.valueset.ActualOption = this.option;
this.parameter1.ValueSet.Add(this.valueset);
this.parameter1.IsOptionDependent = true;
var valueset2 = new ParameterValueSet(Guid.NewGuid(), null, this.uri);
this.parameter1.ValueSet.Add(valueset2);
// **********************************************************************
var row = new ParameterRowViewModel(this.parameter1, this.option, this.session.Object, null);
Assert.IsFalse(row.IsPublishable);
Assert.IsTrue(row.Value.Contains("manual"));
Assert.IsNull(row.StateDependence);
Assert.IsNull(row.MeasurementScale);
Assert.AreEqual(0, row.ContainedRows.Count);
Assert.AreEqual("domain", row.OwnerName);
Assert.AreEqual("dom", row.OwnerShortName);
}
/// <summary>
/// Update the <see cref="ParameterSubscription"/> associated to a <see cref="Parameter"/>
/// </summary>
/// <param name="parameter">The <see cref="Parameter"/></param>
/// <param name="newValueSet">The new <see cref="ParameterValueSet"/></param>
/// <param name="parameterSubscriptions">The <see cref="ParameterSubscription"/></param>
/// <param name="defaultValueArray">The default value array</param>
/// <param name="transaction">The current transaction</param>
/// <param name="partition">The current partition</param>
private void UpdateParameterSubscriptions(
Parameter parameter,
IEnumerable <ParameterValueSet> newValueSet,
IEnumerable <ParameterSubscription> parameterSubscriptions,
ValueArray <string> defaultValueArray,
NpgsqlTransaction transaction,
string partition)
{
var subscriptions = parameterSubscriptions.Where(x => parameter.ParameterSubscription.Contains(x.Iid))
.ToList();
foreach (var parameterValueSet in newValueSet)
{
foreach (var parameterSubscription in subscriptions)
{
var newSubscriptionValueSet =
this.ParameterSubscriptionValueSetFactory.CreateWithDefaultValueArray(
parameterValueSet.Iid,
defaultValueArray);
this.ParameterSubscriptionValueSetService.CreateConcept(
transaction,
partition,
newSubscriptionValueSet,
parameterSubscription);
}
}
}
public void VerifyThatParameterTypeUpdatesAreHandled()
{
// **********************************************************************
var published = new ValueArray <string>(new List <string> {
"manual"
}, this.valueset);
var actual = new ValueArray <string>(new List <string> {
"different"
}, this.valueset);
this.valueset.Published = published;
this.valueset.Manual = actual;
this.valueset.ValueSwitch = ParameterSwitchKind.MANUAL;
this.parameter1.ValueSet.Add(this.valueset);
// **********************************************************************
var row = new ParameterRowViewModel(this.parameter1, this.option, this.session.Object, null);
Assert.AreEqual("pt1", row.Name);
Assert.IsTrue(row.Value.Contains("manual"));
Assert.IsTrue(row.IsPublishable);
Assert.IsNull(row.StateDependence);
Assert.IsNull(row.MeasurementScale);
Assert.AreEqual(0, row.ContainedRows.Count);
Assert.AreEqual("domain", row.OwnerName);
Assert.AreEqual("dom", row.OwnerShortName);
this.parameterType1.Name = "updatept1";
this.parameterType1.RevisionNumber = 100;
CDPMessageBus.Current.SendObjectChangeEvent(this.parameterType1, EventKind.Updated);
Assert.AreEqual("updatept1", row.Name);
}
private void ConfirmSeed()
{
try
{
ConfirmSeedCommand.Executable = false;
// When on testnet, allow clicking through the dialog without any validation.
if (App.Current.ActiveNetwork == BlockChainIdentity.TestNet)
{
if (Input.Length == 0)
{
_wizard.CurrentDialog = new PromptPassphrasesDialog(Wizard, _seed);
return;
}
}
var decodedSeed = WalletSeed.DecodeAndValidateUserInput(Input, _pgpWordList);
if (ValueArray.ShallowEquals(_seed, decodedSeed))
{
_wizard.CurrentDialog = new PromptPassphrasesDialog(Wizard, _seed);
}
else
{
MessageBox.Show("Seed does not match");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Invalid seed");
}
finally
{
ConfirmSeedCommand.Executable = true;
}
}
/// <summary>
/// Update the <see cref="ParameterSubscription"/> associated to a <see cref="Parameter"/>
/// </summary>
/// <param name="parameter">The <see cref="Parameter"/></param>
/// <param name="newOldValueSet">The new <see cref="ParameterValueSet"/></param>
/// <param name="parameterSubscriptions">The <see cref="ParameterSubscription"/></param>
/// <param name="defaultValueArray">The default value array</param>
/// <param name="transaction">The current transaction</param>
/// <param name="partition">The current partition</param>
/// <param name="securityContext">The security context</param>
private void UpdateParameterSubscriptions(
Parameter parameter,
IReadOnlyDictionary <ParameterValueSet, ParameterValueSet> newOldValueSet,
IEnumerable <ParameterSubscription> parameterSubscriptions,
ValueArray <string> defaultValueArray,
NpgsqlTransaction transaction,
string partition,
ISecurityContext securityContext)
{
var subscriptions = parameterSubscriptions.Where(x => parameter.ParameterSubscription.Contains(x.Iid))
.ToList();
var subscriptionValueSets = this.ParameterSubscriptionValueSetService.GetShallow(transaction, partition, subscriptions.SelectMany(x => x.ValueSet), securityContext).
Cast <ParameterSubscriptionValueSet>().ToList();
foreach (var parameterValueSet in newOldValueSet)
{
foreach (var parameterSubscription in subscriptions)
{
var oldSubscriptionValueSet = parameterValueSet.Value != null?subscriptionValueSets.FirstOrDefault(x => x.SubscribedValueSet == parameterValueSet.Value.Iid) : null;
var newSubscriptionValueSet =
this.ParameterSubscriptionValueSetFactory.CreateWithOldValues(
oldSubscriptionValueSet,
parameterValueSet.Key.Iid,
defaultValueArray);
this.ParameterSubscriptionValueSetService.CreateConcept(
transaction,
partition,
newSubscriptionValueSet,
parameterSubscription);
}
}
}
/// <summary>
/// Creates ParameterSubscriptionValueSets for the supplied ParameterValueSets.
/// </summary>
/// <param name="thing">
/// The <see cref="Thing"/> instance that will be inspected.
/// </param>
/// <param name="container">
/// The container instance of the <see cref="Thing"/> that is inspected.
/// </param>
/// <param name="transaction">
/// The current transaction to the database.
/// </param>
/// <param name="partition">
/// The database partition (schema) where the requested resource will be stored.
/// </param>
/// <param name="securityContext">
/// The security-context
/// </param>
private void CreateParameterSubscriptionValueSets(
ParameterSubscription thing,
Thing container,
NpgsqlTransaction transaction,
string partition,
ISecurityContext securityContext)
{
if (!(container is CDP4Common.DTO.ParameterOrOverrideBase parameterOrOverrideBase))
{
throw new InvalidOperationException("The container of a ParameterSubscription can only be a ParameterOrOverrideBase.");
}
var parameterValueSets = parameterOrOverrideBase is CDP4Common.DTO.Parameter
? this.ParameterValueSetService.GetShallow(transaction, partition, parameterOrOverrideBase.ValueSets, securityContext).OfType <CDP4Common.DTO.ParameterValueSetBase>().ToArray()
: this.ParameterOverrideValueSetService.GetShallow(transaction, partition, parameterOrOverrideBase.ValueSets, securityContext).OfType <CDP4Common.DTO.ParameterValueSetBase>().ToArray();
foreach (var parameterValueSet in parameterValueSets)
{
var parameterSubscriptionValueSet =
new ParameterSubscriptionValueSet(Guid.NewGuid(), 0)
{
SubscribedValueSet = parameterValueSet.Iid,
ValueSwitch = ParameterSwitchKind.COMPUTED
};
var valueArray = new ValueArray <string>(this.DefaultValueArrayFactory.CreateDefaultValueArray(parameterValueSet.Manual.Count));
parameterSubscriptionValueSet.Manual = valueArray;
this.ParameterSubscriptionValueSetService.CreateConcept(
transaction,
partition,
parameterSubscriptionValueSet,
thing);
}
}
/// <summary>
/// Set a ValueSet for a scalar ParameterType
/// </summary>
/// <param name="valueset">The <see cref="ParameterValueSetBase"/> to set</param>
private void SetScalarValueSet(ParameterValueSetBase valueset)
{
var manualSet = new ValueArray <string>(new List <string> {
"-"
});
var referenceSet = new ValueArray <string>(new List <string> {
"-"
});
var computedSet = new ValueArray <string>(new List <string> {
"-"
});
var publishedSet = new ValueArray <string>(new List <string> {
"-"
});
var formulaSet = new ValueArray <string>(new List <string> {
"-"
});
valueset.Manual = manualSet;
valueset.Reference = referenceSet;
valueset.Computed = computedSet;
valueset.Published = publishedSet;
valueset.Formula = formulaSet;
valueset.ValueSwitch = ParameterSwitchKind.REFERENCE;
}
public void VerifyThatOnUpdateOfStateTheRowIsUpdated(IViewModelBase <Thing> container, string scenario)
{
// **************************INPUT***************************************
var published = new ValueArray <string>(new List <string> {
"manual"
}, this.valueset);
var actual = new ValueArray <string>(new List <string> {
"different"
}, this.valueset);
this.valueset.Published = published;
this.valueset.Manual = actual;
this.valueset.ValueSwitch = ParameterSwitchKind.MANUAL;
this.valueset.ActualOption = this.option;
this.valueset.ActualState = this.state1;
this.parameter1.ValueSet.Add(this.valueset);
this.parameter1.IsOptionDependent = true;
this.parameter1.StateDependence = this.stateList;
var valueset2 = new ParameterValueSet(Guid.NewGuid(), null, this.uri);
this.parameter1.ValueSet.Add(valueset2);
// **********************************************************************
var row = new ParameterRowViewModel(this.parameter1, this.option, this.session.Object, container);
Assert.AreEqual(1, row.ContainedRows.Count);
this.state1.Kind = ActualFiniteStateKind.FORBIDDEN;
CDPMessageBus.Current.SendObjectChangeEvent(this.state1, EventKind.Updated);
Assert.AreEqual(0, row.ContainedRows.Count);
}
/// <summary>
/// Splits the valueset into chunks based on number of independent and dependent parametertype allocations
/// </summary>
/// <param name="values">The entire value array</param>
/// <param name="nSize">The size of chunks to split into</param>
/// <returns>An IEnumerable of the lists of chunks.</returns>
private IEnumerable <List <string> > SplitValues(ValueArray <string> values, int nSize = 30)
{
for (var i = 0; i < values.Count; i += nSize)
{
yield return(values.ToList().GetRange(i, Math.Min(nSize, values.Count - i)));
}
}
/// <summary>
/// Resolve the properties of the current <see cref="RelationalExpression"/> from its <see cref="DTO.Thing"/> counter-part
/// </summary>
/// <param name="dtoThing">The source <see cref="DTO.Thing"/></param>
internal override void ResolveProperties(DTO.Thing dtoThing)
{
if (dtoThing == null)
{
throw new ArgumentNullException("dtoThing");
}
var dto = dtoThing as DTO.RelationalExpression;
if (dto == null)
{
throw new InvalidOperationException(string.Format("The DTO type {0} does not match the type of the current RelationalExpression POCO.", dtoThing.GetType()));
}
this.ExcludedDomain.ResolveList(dto.ExcludedDomain, dto.IterationContainerId, this.Cache);
this.ExcludedPerson.ResolveList(dto.ExcludedPerson, dto.IterationContainerId, this.Cache);
this.ModifiedOn = dto.ModifiedOn;
this.ParameterType = this.Cache.Get <ParameterType>(dto.ParameterType, dto.IterationContainerId) ?? SentinelThingProvider.GetSentinel <ParameterType>();
this.RelationalOperator = dto.RelationalOperator;
this.RevisionNumber = dto.RevisionNumber;
this.Scale = (dto.Scale.HasValue) ? this.Cache.Get <MeasurementScale>(dto.Scale.Value, dto.IterationContainerId) : null;
this.ThingPreference = dto.ThingPreference;
this.Value = new ValueArray <string>(dto.Value, this);
this.ResolveExtraProperties();
}
/// <summary>
/// Add an entry to the value array only if it is an array type
/// </summary>
/// <param name="value"></param>
public void AddToArray(VariableValue value)
{
if (ValueType == ValueDataType.ArrayType)
{
ValueArray.Add(value);
}
}
/// <summary>
/// Асинхронно вызывает удаленный метод на стороне 1C:Предприятие и возвращает результат.
/// </summary>
/// <param name="имяМодуля">Имя модуля удаленного приложения 1С:Предприятие.</param>
/// <param name="имяМетода">Имя метода (процедуры или функции).</param>
/// <param name="параметры">Параметры метода.</param>
/// <returns></returns>
public async Task <object> ВызватьМетодАсинх(string имяМодуля, string имяМетода, object[] параметры)
{
ValueArray paramArray = ValueBase.From(параметры) as ValueArray;
Task <ExecuteMethodResponse> task = this.SoapКлиент.ExecuteMethodAsync(имяМодуля, имяМетода, paramArray);
return((await task)[email protected](this));
}
internal SubtractArray()
{
List<Value> list = new List<Value>();
list.Add(PatternData.Single("a", ValueType.Int));
list.Add(PatternData.Single("b", ValueType.Int));
ValueArray array = new ValueArray(list);
Init(array);
}
public Chunk()
{
count = 0;
capacity = 0;
values = null;
lines = new List <int>();
constants = new ValueArray();
}
public void VerifyCreateParameterOverride()
{
var vm = new ProductTreeViewModel(this.option, this.session.Object, this.thingDialogNavigationService.Object, this.panelNavigationService.Object, this.dialogNavigationService.Object, null);
var revisionNumber = typeof(Iteration).GetProperty("RevisionNumber");
revisionNumber.SetValue(this.iteration, 50);
var elementdef = new ElementDefinition(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
Container = this.iteration
};
var boolParamType = new BooleanParameterType(Guid.NewGuid(), this.assembler.Cache, this.uri);
var elementUsage = new ElementUsage(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
Container = elementdef,
ElementDefinition = elementdef
};
var parameter = new Parameter(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
Owner = this.domain, Container = elementUsage, ParameterType = boolParamType
};
elementdef.Parameter.Add(parameter);
var published = new ValueArray <string>(new List <string> {
"published"
});
var paramValueSet = new ParameterValueSet(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
Published = published,
Manual = published,
Computed = published,
ValueSwitch = ParameterSwitchKind.COMPUTED
};
parameter.ValueSet.Add(paramValueSet);
var usageRow = new ElementUsageRowViewModel(elementUsage, this.option, this.session.Object, null);
var parameterRow = new ParameterRowViewModel(parameter, this.option, this.session.Object, usageRow);
this.iteration.TopElement = elementdef;
vm.SelectedThing = parameterRow;
Assert.IsTrue(vm.CreateOverrideCommand.CanExecute(null));
vm.SelectedThing = null;
vm.CreateOverrideCommand.Execute(null);
this.session.Verify(x => x.Write(It.IsAny <OperationContainer>()), Times.Never);
vm.SelectedThing = vm.TopElement.Single();
vm.CreateOverrideCommand.Execute(null);
this.session.Verify(x => x.Write(It.IsAny <OperationContainer>()), Times.Never);
vm.SelectedThing = parameterRow;
vm.CreateOverrideCommand.Execute(parameter);
this.session.Verify(x => x.Write(It.IsAny <OperationContainer>()));
vm.PopulateContextMenu();
Assert.AreEqual(6, vm.ContextMenu.Count);
}
private static IHeightMap GenerateRocks(int seed, int x, int y, double density)
{
CellularAutomaton ca = new CellularAutomaton(seed, new RuleSet(Lerp(0.1, 0.3, density), false, (region, generation) => region.GetNeighbors() > 2));
IHeightMap layer1 = new BooleanMap(ca.Generate(x, y, 4));
IHeightMap layer2 = new BooleanMap(ca.Generate(x, y, 2));
return(new HeightMap(2, ValueArray.Create(x, y, (i, j) => layer1[i, j] + layer2[i, j])));
}
public void CopyFrom(ValueArray <T> array)
{
Clear();
for (int i = 0; i < array.Count; i++)
{
T value = array[i];
Add(ref value);
}
}
public void AddWorks()
{
_myArray = default;
_myArray.Add(77);
_myArray.Add(78);
Assert.Equal(2, _myArray.Count);
Assert.Equal(77, _myArray[0]);
Assert.Equal(78, _myArray[1]);
}
public void RemoveWorks()
{
_myArray = default;
_myArray.Add(1);
Assert.Single(_myArray);
_myArray.Remove(1);
Assert.Empty(_myArray);
}
public void VerifyThatValueArrayToStringWorksWithStrings()
{
var array = new ValueArray <string>(new List <string> {
"abc", "def", "3", "4.1"
});
var s = array.ToString();
Assert.AreEqual("{\"abc\"; \"def\"; \"3\"; \"4.1\"}", s);
}
public void VerifyThatValueArrayToStringWorks()
{
var array = new ValueArray <float>(new List <float> {
1, 2, 3, 4.1f
});
var s = array.ToString();
Assert.AreEqual("{1; 2; 3; 4.1}", s);
}
public void VerifyThatParametersArePlacedCorrectly()
{
var revision = typeof(ElementDefinition).GetProperty("RevisionNumber");
// Test input
var valueSet = new ParameterValueSet(Guid.NewGuid(), this.cache, this.uri);
var manualSet = new ValueArray <string>(new List <string> {
"manual"
});
var referenceSet = new ValueArray <string>(new List <string> {
"ref"
});
var computedSet = new ValueArray <string>(new List <string> {
"computed"
});
var publishedSet = new ValueArray <string>(new List <string> {
"published"
});
valueSet.Manual = manualSet;
valueSet.Reference = referenceSet;
valueSet.Computed = computedSet;
valueSet.Published = publishedSet;
this.parameter1.ValueSet.Add(valueSet);
this.elementDefinition.Parameter.Add(this.parameter1);
// **********
var vm = new ElementDefinitionRowViewModel(this.elementDefinition, this.activeDomain, this.session.Object, null, this.obfuscationService.Object);
var group1Row = vm.ContainedRows.Single(x => x.Thing == this.parameterGroup1);
var group3Row = group1Row.ContainedRows.Single();
Assert.AreEqual(3, vm.ContainedRows.Count);
// move parameter to group1
revision.SetValue(this.parameter1, 1);
this.parameter1.Group = this.parameterGroup1;
CDPMessageBus.Current.SendObjectChangeEvent(this.parameter1, EventKind.Updated);
Assert.AreEqual(2, vm.ContainedRows.Count);
Assert.AreEqual(2, group1Row.ContainedRows.Count);
// move parameter to group3
revision.SetValue(this.parameter1, 2);
this.parameter1.Group = this.parameterGroup3;
CDPMessageBus.Current.SendObjectChangeEvent(this.parameter1, EventKind.Updated);
Assert.AreEqual(2, vm.ContainedRows.Count);
Assert.AreEqual(1, group1Row.ContainedRows.Count);
Assert.AreEqual(1, group3Row.ContainedRows.Count);
// move parameter to root
revision.SetValue(this.parameter1, 3);
this.parameter1.Group = null;
CDPMessageBus.Current.SendObjectChangeEvent(this.parameter1, EventKind.Updated);
Assert.AreEqual(3, vm.ContainedRows.Count);
Assert.AreEqual(1, group1Row.ContainedRows.Count);
Assert.AreEqual(0, group3Row.ContainedRows.Count);
}
internal Add()
{
SetDocString("Return [0] + [1].");
List<Value> list = new List<Value>();
list.Add(PatternData.Single("a", ValueType.Number));
list.Add(PatternData.Single("b", ValueType.Number));
ValueArray array = new ValueArray(list);
Init(array);
}
internal IsAnyEqual()
{
SetDocString("If first element is equal to anything in second array, return true, else false.");
List<Value> list = new List<Value>();
list.Add(PatternData.Single("value"));
list.Add(PatternData.Single("array", ValueType.Array));
ValueArray array = new ValueArray(list);
Init(array);
}
internal IsEqual()
{
SetDocString("If both elements in array are equal, return true, else false.");
List<Value> list = new List<Value>();
list.Add(PatternData.Single("a"));
list.Add(PatternData.Single("b"));
ValueArray array = new ValueArray(list);
Init(array);
}
public void TestArrayParams()
{
ScopeChain scope = new ScopeChain();
scope.SetValue("+", new TestSum());
ValueDelimiter square = new ValueDelimiter("]", DelimiterType.AsArray);
scope.SetValue("[", square);
{ // create postfix function that takes [ a b ]
List<Value> list = new List<Value>();
list.Add(PatternData.Single("a", ValueType.Int));
list.Add(PatternData.Single("b", ValueType.Int));
ValueArray array = new ValueArray(list);
List<string> body = new List<string>();
body.Add("a + b");
CreateFunction.Do(scope, "add", null, array, body);
}
{ // try out the function
DelimiterList list = ParseLine.Do("add [ 2 5 ]", scope);
Value value = EvalList.Do(list.Nodes, scope);
Assert.AreEqual(7, value.AsInt);
}
}
internal Combine()
{
SetDocString("Concatenates two arrays or maps.");
List<Value> list = new List<Value>();
list.Add(PatternData.Single("a"));
list.Add(PatternData.Single("b"));
ValueArray array = new ValueArray(list);
Init(array);
}
public override void DoRows(Parse rows)
{
memberNameCells = new CellRange(rows.Parts);
rowWidth = rows.Parts.Size;
valueCells = new ValueArray(RepeatString);
base.DoRows(rows.More);
}
/// <summary>
/// Create an instance of LibraryModelProgram for a given assembly
/// </summary>
/// <param name="modAssembly">Loaded assembly</param>
/// <param name="modelName">Name of the model namespace to be loaded.
/// Only classes in the model namespace will be loaded.</param>
/// <param name="featureNames">The names of features to be loaded. If null, all
/// features will be loaded for the given modelName. See <see cref="FeatureAttribute"/>.</param>
/// <exception cref="ModelProgramUserException">Thrown if there is a usage error in the given assembly.</exception>
public LibraryModelProgram(Assembly modAssembly, string modelName, Set<string>/*?*/ featureNames)
{
if (string.IsNullOrEmpty(modelName))
throw new ArgumentNullException("modelName");
InterpretationContext context = (null == featureNames ?
new InterpretationContext() :
new InterpretationContext(featureNames));
Type/*?*/[]/*?*/ allTypes = modAssembly.GetTypes();
List<Field> stateVars = new List<Field>();
Dictionary<Symbol, ActionInfo> aInfoMap = new Dictionary<Symbol, ActionInfo>();
Dictionary<Type, StatePredicate> acceptingStateConditions = new Dictionary<Type, StatePredicate>();
Dictionary<Type, StatePredicate> stateInvariants = new Dictionary<Type, StatePredicate>();
Dictionary<Type, StatePredicate> stateFilters = new Dictionary<Type, StatePredicate>();
//Dictionary<Type, TransitionPropertyGenerator> transitionPropertyGenerators = new Dictionary<Type, TransitionPropertyGenerator>();
bool modelIsEmpty = true;
#region Get state variables, actions, invariants, accepting state conditions, and state filters
abstractSorts = new Set<Symbol>();
foreach (Type t in allTypes)
{
try
{
// ignore any compiler-generated types, such as iterators.
if (ReflectionHelper.IsCompilerGenerated(t))
continue;
// Collect state variables, actions, invariants and accepting state conditions.
if (ReflectionHelper.IsInModel(t, modelName, featureNames))
{
// Register the sort for this type
context.RegisterSortType(AbstractValue.TypeSort(t), t);
// Check if the sort is abstract
if (AbstractValue.IsTypeAbstractSort(t)) abstractSorts=abstractSorts.Add(AbstractValue.TypeSort(t));
// Only extract variables and actions from class types.
if (!t.IsClass)
continue;
// clear flag that detects model namespace spelling errors
modelIsEmpty = false;
// Collect state variables
foreach (FieldInfo field in ReflectionHelper.GetModelVariables(t))
stateVars.Add(new Field(field));
Set<string> actionMethodNames = Set<string>.EmptySet; // used to detect duplicates
// Collect actions
foreach (MethodInfo methodInfo in ReflectionHelper.GetMethodsForActions(t))
{
try
{
if (actionMethodNames.Contains(methodInfo.Name))
throw new ModelProgramUserException("Duplicate action method name '" + methodInfo.Name + "' found. Action methods may not use overloaded names.");
if (!methodInfo.IsStatic)
{
//check that the the declaring class is a labeled instance
//or else say that probably the static keyword is missing
if (methodInfo.DeclaringType.BaseType == null ||
methodInfo.DeclaringType.BaseType.Name != "LabeledInstance`1" ||
methodInfo.DeclaringType.BaseType.GetGenericArguments()[0] != methodInfo.DeclaringType)
throw new ModelProgramUserException("Since the action method '" + methodInfo.Name + "' is non-static, the class '" + methodInfo.DeclaringType.Name + "' must directly inherit from 'LabeledInstance<" + methodInfo.DeclaringType.Name + ">'." +
"\nDid you perhaps forget to declare the method 'static'?");
}
//check that the action parameter types are valid modeling types
foreach (ParameterInfo pInfo in methodInfo.GetParameters())
if (!(pInfo.ParameterType.IsPrimitive ||
pInfo.ParameterType.IsEnum ||
pInfo.ParameterType == typeof(string) ||
ReflectionHelper.ImplementsIAbstractValue(pInfo.ParameterType)))
throw new ModelProgramUserException(
"\nThe parameter '" + pInfo.Name + "' of '" + methodInfo.Name + "' does not a have valid modeling type. " +
"\nA valid modeling type is either: a primitive type, an enum, a string, or a type that implements 'NModel.Internals.IAbstractValue'." +
"\nIn particular, collection types in 'System.Collections' and 'System.Collections.Generic' are not valid modeling types." +
"\nValid modeling types are collection types like 'Set' and 'Map' defined in the 'NModel' namespace, " +
"\nas well as user defined types that derive from 'CompoundValue'.");
actionMethodNames = actionMethodNames.Add(methodInfo.Name);
Method method = new Method(methodInfo);
#region RequirementsMetrics2
// Requirements metrics
// methodInfo is only actions
// Collect the requirements from the enabling-actions below (after this loop)
if (!allModeledRequirements.ContainsKey(methodInfo.Name))
allModeledRequirements =
allModeledRequirements.Add(methodInfo.Name,
ReflectionHelper.GetRequirementsInMethod(methodInfo));
// Collect the requirements from the enabling-actions
foreach (MethodInfo enablingMethodInfo in ReflectionHelper.GetEnablingMethods(methodInfo))
{
if (!allModeledRequirements.ContainsKey(enablingMethodInfo.Name))
{
Set<Pair<string, string>> requirements = new Set<Pair<string, string>>
(ReflectionHelper.GetEnablingMethodsRequirements(enablingMethodInfo));
allModeledRequirements =
allModeledRequirements.Add(enablingMethodInfo.Name, requirements);
}
}
#endregion
foreach (ActionAttribute actionAttribute in ReflectionHelper.GetModelActionAttributes(methodInfo))
{
CompoundTerm/*?*/ startActionLabel;
CompoundTerm/*?*/ finishActionLabel;
ReflectionHelper.GetActionLabel(methodInfo, actionAttribute, out startActionLabel, out finishActionLabel);
ActionMethodFinish/*?*/ finishActionMethod = null;
if (finishActionLabel != null)
{
finishActionMethod = InsertActionMethodFinish(method, finishActionLabel, aInfoMap);
}
if (startActionLabel != null)
{
InsertActionMethodStart(method, startActionLabel, finishActionMethod, aInfoMap);
}
}
}
catch (ModelProgramUserException e)
{
string msg = "method " + methodInfo.Name + ", " + e.Message;
throw new ModelProgramUserException(msg);
}
}
// to do: collect transition properties
// Collect state invariants
//StatePredicate sp1 = StatePredicate.GetPredicates(t, GetStateInvariantMethodNames(t));
//if (null != sp1)
// stateInvariants.Add(t, sp1);
// Collect accepting state conditions
StatePredicate sp2 = StatePredicate.GetAcceptingStateCondition(t);
if (null != sp2)
acceptingStateConditions.Add(t, sp2);
// Collect state invariants
StatePredicate sp3 = StatePredicate.GetStateInvariant(t);
if (null != sp3)
stateInvariants.Add(t, sp3);
//collect state filters
StatePredicate sp4 = StatePredicate.GetStateFilter(t);
if (null != sp4)
stateFilters.Add(t, sp4);
}
}
catch (ModelProgramUserException e)
{
string msg = "In class " + t.Name + ", " + e.Message;
throw new ModelProgramUserException(msg);
}
}
if (modelIsEmpty)
throw new ModelProgramUserException("No classes found in model namespace " + modelName + ". Did you misspell?");
#endregion
// todo: Collect "sorts" for each type. Walk type tree of state variables and
// action arguments to do this.
Symbol[] aSymbols = new Symbol[aInfoMap.Keys.Count];
int j = 0;
foreach (Symbol a in aInfoMap.Keys)
aSymbols[j++] = a;
Field[] sFields = stateVars.ToArray();
StateVariable[] sVars = new StateVariable[sFields.Length];
string[] lNames = new string[sVars.Length];
ValueArray<string> locNames;
for (int i = 0; i < sVars.Length; i++)
{
sVars[i] = sFields[i].stateVariable;
lNames[i] = sFields[i].stateVariable.Name;
}
locNames = new ValueArray<string>(lNames);
string nameExt = "";
if (featureNames != null && featureNames.Count > 0)
{
nameExt += "[";
for (int i = 0; i < featureNames.Count; i++)
{
nameExt += featureNames.Choose(i);
if (i < featureNames.Count - 1)
nameExt += ",";
}
nameExt += "]";
}
this.name = modelName + nameExt;
// this.generator = generator;
this.stateFields = sFields;
this.locationNames = locNames;
this.stateVariables = sVars;
this.actionSymbols = new Set<Symbol>(aSymbols);
this.actionInfoMap = aInfoMap;
this.finishActionSymbols = LibraryModelProgram.CreateStartFinishMap(aInfoMap);
this.modelAssembly = modAssembly;
this.context = context;
this.currentState = GetInitialState();
this.stateChangedPredicate = false;
this.acceptingStateConditions = acceptingStateConditions;
this.stateInvariants = stateInvariants;
this.stateFilters = stateFilters;
}
/// <summary>
/// Evaluates a token, possibly requesting the previous and next values.
/// Returns a value.
/// </summary>
/// <param name="token">token representing a function or variable</param>
/// <param name="scope">used to request functions, variables, and delimiters if there's no scope attached to the node</param>
/// <param name="nodes">used to request previous and next nodes</param>
internal static Value Do(DelimiterNode node, IScope scope, INodeRequestor nodes, ILineRequestor requestor)
{
if (node.Value != null)
{ // node has already been evaluated
return node.Value;
}
else if (node.Token != null)
{ // function/variable or built-in
Token token = node.Token;
Value value = scope.GetValue(token);
if (value is ValueFunction && nodes != null)
{
ValueFunction function = value as ValueFunction;
// get previous & next nodes if needed
DelimiterNode previous = (function.ConsumesPrevious ? nodes.GetPrevious() : null);
DelimiterNode next = (function.ConsumesNext ? nodes.GetNext() : null);
scope.FunctionName = token.Value;
// evaluate
try
{
return function.Eval(previous, next, scope, scope, nodes, requestor);
}
catch (Loki3Exception e)
{ // this function is the correct context if there isn't already one there
if (!e.Errors.ContainsKey(Loki3Exception.keyFunction))
e.AddFunction(token.Value);
if (!e.Errors.ContainsKey(Loki3Exception.keyScope))
e.AddScope(scope);
throw e;
}
}
else if (value != null)
{
return value;
}
else
{
return EvalBuiltin.Do(token);
}
}
else if (node.List != null)
{ // delimited list of nodes
Value value = null;
DelimiterList list = node.List;
IScope listScope = (list.Scope != null ? list.Scope : scope);
DelimiterType type = list.Delimiter.DelimiterType;
// get contents as a Value
switch (type)
{
case DelimiterType.AsString:
value = new ValueString(list.Original);
break;
case DelimiterType.AsValue:
value = EvalList.Do(list.Nodes, listScope);
break;
case DelimiterType.AsArray:
List<Value> values = new List<Value>(list.Nodes.Count);
foreach (DelimiterNode subnode in list.Nodes)
{ // note: 'nodes' is null so functions don't get evaled
Value subvalue = Do(subnode, listScope, null, requestor);
values.Add(subvalue);
}
value = new ValueArray(values);
break;
case DelimiterType.AsEvaledArray:
value = EvalList.DoEvaledArray(list.Nodes, listScope);
break;
case DelimiterType.AsRaw:
value = new ValueRaw(list, listScope);
break;
case DelimiterType.AsArrayOfRaw:
List<Value> rawvalues = new List<Value>(list.Nodes.Count);
foreach (DelimiterNode subnode in list.Nodes)
rawvalues.Add(new ValueRaw(subnode, listScope));
value = new ValueArray(rawvalues);
break;
}
// run contents through a function if specified
ValueFunction function = list.Delimiter.Function;
if (function == null)
return value;
DelimiterNode next = new DelimiterNodeValue(value);
return function.Eval(null, next, scope, scope, nodes, requestor);
}
return new ValueNil();
}
internal LogicalOr()
{
SetDocString("Return true if either value in array are true.");
List<Value> list = new List<Value>();
list.Add(PatternData.Single("a", ValueType.Bool));
list.Add(PatternData.Single("b", ValueType.Raw));
ValueArray array = new ValueArray(list);
Init(array);
}
/// <summary>Parameter that's a single named value that's one of a set of options</summary>
internal static Value Single(string name, ValueArray oneOf)
{
ValueString vName = new ValueString(name);
PatternData data = new PatternData(vName);
data.OneOf = oneOf;
return vName;
}
// Returns the number of methods newly added to the dictionary.
private bool AddMethodsOverwriteExisting(
MemberInfo/*!*/[]/*!*/ newOverloads, RubyMethodGroupInfo/*!*/[] overloadOwners) {
bool anyChange = false;
for (int i = 0; i < newOverloads.Length; i++) {
var method = (MethodBase)newOverloads[i];
if (IsVisible(method)) {
var paramTypes = new ValueArray<Type>(ReflectionUtils.GetParameterTypes(method.GetParameters()));
if (_allMethods == null) {
_allMethods = new Dictionary<ValueArray<Type>, ClrOverloadInfo>();
}
_allMethods[paramTypes] = new ClrOverloadInfo {
Overload = method,
Owner = (overloadOwners != null) ? overloadOwners[i] : null
};
anyChange = true;
}
}
return anyChange;
}
public void TestArray()
{
List<Value> list = new List<Value>();
list.Add(PatternData.Single("a", ValueType.Int));
list.Add(PatternData.Single("b", ValueType.String));
ValueArray pattern = new ValueArray(list);
Value match = null, leftover = null;
{ // single object - not a match
Value input = new ValueInt(37);
Assert.IsFalse(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover));
}
{ // array with one item - match with leftover
List<Value> one = new List<Value>();
one.Add(new ValueInt(5));
ValueArray input = new ValueArray(one);
Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover));
Assert.AreEqual(1, match.AsArray.Count);
Assert.AreEqual(5, match.AsArray[0].AsInt);
Assert.AreEqual(1, leftover.AsArray.Count);
Assert.AreEqual("b", leftover.AsArray[0].AsString);
}
{ // array with two items of proper type - match
List<Value> two = new List<Value>();
two.Add(new ValueInt(5));
two.Add(new ValueString("hello"));
ValueArray input = new ValueArray(two);
Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover));
Assert.AreEqual(2, match.AsArray.Count);
Assert.AreEqual(5, match.AsArray[0].AsInt);
Assert.AreEqual("hello", match.AsArray[1].AsString);
Assert.AreEqual(null, leftover);
}
{ // array with two items of wrong type - not a match
List<Value> two = new List<Value>();
two.Add(new ValueInt(5));
two.Add(new ValueFloat(2.718));
ValueArray input = new ValueArray(two);
Assert.IsFalse(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover));
}
{ // array with three items - not a match
List<Value> three = new List<Value>();
three.Add(new ValueInt(5));
three.Add(new ValueString("hello"));
three.Add(new ValueString("goodbye"));
ValueArray input = new ValueArray(three);
Assert.IsFalse(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover));
}
{ // array with three items & smaller pattern is allowed
List<Value> three = new List<Value>();
three.Add(new ValueInt(5));
three.Add(new ValueString("hello"));
three.Add(new ValueString("goodbye"));
ValueArray input = new ValueArray(three);
Assert.IsTrue(PatternChecker.Do(input, pattern, true/*bShortPat*/, out match, out leftover));
Assert.AreEqual(2, match.AsArray.Count);
Assert.AreEqual(5, match.AsArray[0].AsInt);
Assert.AreEqual("hello", match.AsArray[1].AsString);
Assert.AreEqual(null, leftover);
}
}
public void TestMapFromArrayPattern()
{
List<Value> list = new List<Value>();
list.Add(PatternData.Single("a", ValueType.Int));
list.Add(PatternData.Single("b", new ValueInt(17)));
ValueArray pattern = new ValueArray(list);
Value match = null, leftover = null;
{ // get a & b
Map map = new Map();
map["a"] = new ValueInt(42);
map["b"] = new ValueInt(31);
ValueMap input = new ValueMap(map);
Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover));
Assert.AreEqual(2, match.AsMap.Count);
Assert.AreEqual(42, match.AsMap["a"].AsInt);
Assert.AreEqual(31, match.AsMap["b"].AsInt);
Assert.AreEqual(null, leftover);
}
{ // fill in default for b
Map map = new Map();
map["a"] = new ValueInt(42);
ValueMap input = new ValueMap(map);
Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover));
Assert.AreEqual(2, match.AsMap.Count);
Assert.AreEqual(42, match.AsMap["a"].AsInt);
Assert.AreEqual(17, match.AsMap["b"].AsInt);
Assert.AreEqual(null, leftover);
}
{ // leftover
Map map = new Map();
map["b"] = new ValueInt(31);
ValueMap input = new ValueMap(map);
Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover));
Assert.AreEqual(1, match.AsMap.Count);
Assert.AreEqual(31, match.AsMap["b"].AsInt);
Assert.AreEqual(1, leftover.AsMap.Count);
Assert.AreEqual("a", leftover.AsMap["a"].AsString);
}
{ // get a & b, ignore c because bShortPat=true
Map map = new Map();
map["a"] = new ValueInt(42);
map["b"] = new ValueInt(31);
map["c"] = new ValueInt(31);
ValueMap input = new ValueMap(map);
Assert.IsTrue(PatternChecker.Do(input, pattern, true/*bShortPat*/, out match, out leftover));
Assert.AreEqual(2, match.AsMap.Count);
Assert.AreEqual(42, match.AsMap["a"].AsInt);
Assert.AreEqual(31, match.AsMap["b"].AsInt);
Assert.AreEqual(null, leftover);
}
{ // missing key
List<Value> list2 = new List<Value>();
list2.Add(PatternData.Single("a", ValueType.Int));
list2.Add(PatternData.Rest("other"));
ValueArray pattern2 = new ValueArray(list2);
Map map = new Map();
map["b"] = new ValueInt(31);
map["c"] = new ValueInt(31);
ValueMap input = new ValueMap(map);
Assert.IsFalse(PatternChecker.Do(input, pattern2, true/*bShortPat*/, out match, out leftover));
// but if "a" is present, it matches
map["a"] = new ValueInt(42);
Assert.IsTrue(PatternChecker.Do(input, pattern2, true/*bShortPat*/, out match, out leftover));
}
}
public void TestRestOfArray()
{
List<Value> list = new List<Value>();
list.Add(PatternData.Single("a", ValueType.Int));
list.Add(PatternData.Rest("b"));
ValueArray pattern = new ValueArray(list);
Value match = null, leftover = null;
{ // array with one item - remainder is empty
List<Value> one = new List<Value>();
one.Add(new ValueInt(5));
ValueArray input = new ValueArray(one);
Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover));
Assert.AreEqual(2, match.AsArray.Count);
Assert.AreEqual(5, match.AsArray[0].AsInt);
List<Value> rest = match.AsArray[1].AsArray;
Assert.AreEqual(0, rest.Count);
Assert.AreEqual(null, leftover);
}
{ // array with two items of proper type - single remainder
List<Value> two = new List<Value>();
two.Add(new ValueInt(5));
two.Add(new ValueString("hello"));
ValueArray input = new ValueArray(two);
Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover));
Assert.AreEqual(2, match.AsArray.Count);
Assert.AreEqual(5, match.AsArray[0].AsInt);
List<Value> rest = match.AsArray[1].AsArray;
Assert.AreEqual(1, rest.Count);
Assert.AreEqual("hello", rest[0].AsString);
Assert.AreEqual(null, leftover);
}
{ // array with three items of proper type - two items in remainder
List<Value> three = new List<Value>();
three.Add(new ValueInt(5));
three.Add(new ValueString("hello"));
three.Add(new ValueInt(7));
ValueArray input = new ValueArray(three);
Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover));
Assert.AreEqual(2, match.AsArray.Count);
Assert.AreEqual(5, match.AsArray[0].AsInt);
List<Value> rest = match.AsArray[1].AsArray;
Assert.AreEqual(2, rest.Count);
Assert.AreEqual("hello", rest[0].AsString);
Assert.AreEqual(7, rest[1].AsInt);
Assert.AreEqual(null, leftover);
}
}
public void TestArrayDefault()
{
List<Value> list = new List<Value>();
list.Add(PatternData.Single("a", ValueType.Int));
list.Add(PatternData.Single("b", new ValueInt(17)));
ValueArray pattern = new ValueArray(list);
Value match = null, leftover = null;
{ // single object - not a match
Value input = new ValueInt(37);
Assert.IsFalse(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover));
}
{ // array with one item - match with default added
List<Value> one = new List<Value>();
one.Add(new ValueInt(5));
ValueArray input = new ValueArray(one);
Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover));
Assert.AreEqual(2, match.AsArray.Count);
Assert.AreEqual(5, match.AsArray[0].AsInt);
Assert.AreEqual(17, match.AsArray[1].AsInt);
Assert.AreEqual(null, leftover);
}
{ // array with two items of proper type - match
List<Value> two = new List<Value>();
two.Add(new ValueInt(5));
two.Add(new ValueString("hello"));
ValueArray input = new ValueArray(two);
Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover));
Assert.AreEqual(2, match.AsArray.Count);
Assert.AreEqual(5, match.AsArray[0].AsInt);
Assert.AreEqual("hello", match.AsArray[1].AsString);
Assert.AreEqual(null, leftover);
}
}
public void TestArrayOneOf()
{
// passed value must be a member of this list
List<Value> options = new List<Value>();
options.Add(new ValueInt(5));
options.Add(new ValueInt(6));
ValueArray oneOf = new ValueArray(options);
List<Value> list = new List<Value>();
list.Add(PatternData.Single("a", oneOf));
ValueArray pattern = new ValueArray(list);
Value match = null, leftover = null;
{ // single object that's not a match
Value input = new ValueInt(4);
Assert.IsFalse(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover));
}
{ // array with one item that matches one of the options
List<Value> one = new List<Value>();
one.Add(new ValueInt(6));
ValueArray input = new ValueArray(one);
Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover));
Assert.AreEqual(1, match.AsArray.Count);
Assert.AreEqual(6, match.AsArray[0].AsInt);
Assert.AreEqual(null, leftover);
}
}
internal LogicalAnd()
{
SetDocString("Return true only if both values of array are true.");
List<Value> list = new List<Value>();
list.Add(PatternData.Single("a", ValueType.Bool));
list.Add(PatternData.Single("b", ValueType.Raw));
ValueArray array = new ValueArray(list);
Init(array);
}
