/// <summary> /// Initializes the column index associated to the given <paramref name="parameterValueSet"/> /// </summary> /// <param name="parameterValueSet"> /// The given <see cref="ParameterValueSet"/> /// </param> private void SetContentColumnIndex(ParameterValueSetBase parameterValueSet) { var parameter = (Parameter)parameterValueSet.Container; if (parameter.ParameterType is CompoundParameterType compoundParameterType) { // NOTE: call Select so that 'component' has a proper type, not object foreach (var component in compoundParameterType.Component.Select(x => x)) { this.SetContentColumnIndex(( parameter.ParameterType.ShortName, component.ParameterType.ShortName, component.Scale?.ShortName ?? "", parameterValueSet.ActualOption?.ShortName ?? "", parameter.StateDependence?.ShortName ?? "", parameterValueSet.ActualState?.ShortName ?? ""), -1); } } else { this.SetContentColumnIndex(( parameter.ParameterType.ShortName, "", parameter.Scale?.ShortName ?? "", parameterValueSet.ActualOption?.ShortName ?? "", parameter.StateDependence?.ShortName ?? "", parameterValueSet.ActualState?.ShortName ?? ""), -1); } }
/// <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; }
/// <summary> /// Add the value set update listener for this row /// </summary> /// <param name="thing">The <see cref="ParameterValueSetBase"/> which updates need to be handled in this row</param> private void AddValueSetListener(ParameterValueSetBase thing) { if (this.isValueSetListenerInitialized) { return; } Func <ObjectChangedEvent, bool> discriminator = objectChange => objectChange.EventKind == EventKind.Updated && objectChange.ChangedThing.RevisionNumber > this.RevisionNumber; Action <ObjectChangedEvent> action = x => this.SetValues(); if (this.AllowMessageBusSubscriptions) { var listener = CDPMessageBus.Current.Listen <ObjectChangedEvent>(thing) .Where(discriminator) .ObserveOn(RxApp.MainThreadScheduler) .Subscribe(action); this.Disposables.Add(listener); } else { var parameterValueSetBaseObserver = CDPMessageBus.Current.Listen <ObjectChangedEvent>(typeof(ParameterValueSetBase)); this.Disposables.Add( this.MessageBusHandler.GetHandler <ObjectChangedEvent>().RegisterEventHandler(parameterValueSetBaseObserver, new ObjectChangedMessageBusEventHandlerSubscription(thing, discriminator, action))); } this.isValueSetListenerInitialized = true; }
/// <summary> /// Update a <see cref="ParameterValueSetBase"/> that may or may not be option and/or state dependent /// </summary> /// <param name="valueSet"> /// The <see cref="ParameterValueSetBase"/> to update /// </param> public void UpdateValueSets(ParameterValueSetBase valueSet) { var actualOption = valueSet.ActualOption; var actualState = valueSet.ActualState; if (actualOption != null) { var optionRow = this.ContainedRows.Cast <ParameterOptionRowViewModel>().Single(x => x.ActualOption == actualOption); if (actualState != null) { var actualStateRow = optionRow.ContainedRows.Cast <ParameterStateRowViewModel>().Single(x => x.ActualState == actualState); this.UpdateScalarOrCompoundValueSet(valueSet, actualStateRow); } else { this.UpdateScalarOrCompoundValueSet(valueSet, optionRow); } } else { if (actualState != null) { var actualStateRow = this.ContainedRows.Cast <ParameterStateRowViewModel>().Single(x => x.ActualState == actualState); this.UpdateScalarOrCompoundValueSet(valueSet, actualStateRow); } else { this.UpdateScalarOrCompoundValueSet(valueSet); } } }
/// <summary> /// Set the value for this row from the <see cref="ParameterOrOverrideBase"/> and the associated <see cref="ParameterValueSetBase"/> /// </summary> /// <param name="parameterOrOveride">The <see cref="ParameterOrOverrideBase"/></param> /// <param name="valueSet">The <see cref="ParameterValueSetBase"/></param> /// <param name="index">The Index of the Value to get</param> public void SetScalarValue(ParameterOrOverrideBase parameterOrOveride, ParameterValueSetBase valueSet, int?index = null) { this.Value = index.HasValue && valueSet.Published.Count() > index ? valueSet.Published[index.Value] : valueSet.Published.FirstOrDefault(); var actualValue = index.HasValue && valueSet.Published.Count() > index ? valueSet.ActualValue[index.Value] : valueSet.ActualValue.FirstOrDefault(); // propagate values to aid in modelcode updates this.valueSetIndex = index; this.valueSet = valueSet; this.UpdateModelCode(); this.Switch = valueSet.ValueSwitch; if (this.Value == null || actualValue == null) { return; } if (this.Value != actualValue) { this.IsPublishable = true; } if (this.Scale != null) { this.Value += " [" + this.Scale.ShortName + "]"; } }
/// <summary> /// Set the value for this row from the associated <see cref="ParameterValueSetBase"/> /// </summary> /// <param name="valueSet">The <see cref="ParameterValueSetBase"/></param> public void SetScalarValue(ParameterValueSetBase valueSet) { // perform checks to see if this is indeed a scalar value if (valueSet.Published.Count() > 1) { logger.Warn("The value set of Parameter or override {0} is marked as Scalar, yet has multiple values.", this.Thing.Iid); } this.Value = valueSet.Published.FirstOrDefault(); // handle zero values returned if (this.Value == null) { logger.Warn("The value set of Parameter or override {0} is marked as Scalar, yet has no values.", this.Thing.Iid); this.Value = "-"; } if (this.Thing.Scale != null) { this.Value += " [" + this.Thing.Scale.ShortName + "]"; } this.Switch = valueSet.ValueSwitch; // propagate values to aid in modelcode updates this.valueSet = valueSet; this.UpdateModelCode(); }
/// <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; }
/// <summary> /// Set the values of the <see cref="Dto.ParameterValueSetBase"/> with the values of a original <see cref="ParameterValueSetBase"/> /// </summary> /// <param name="valueSet">The <see cref="Dto.ParameterValueSetBase"/></param> /// <param name="originalValueSet">The <see cref="ParameterValueSetBase"/></param> private void SetValueSetValues(Dto.ParameterValueSetBase valueSet, ParameterValueSetBase originalValueSet) { valueSet.Manual = originalValueSet.Manual; valueSet.Reference = originalValueSet.Reference; valueSet.ValueSwitch = originalValueSet.ValueSwitch; valueSet.Formula = originalValueSet.Formula; valueSet.Computed = originalValueSet.Computed; }
/// <summary> /// Generate a cell name for the given <paramref name="parameterValueSetBase"/>. Note that non-<see cref="ParameterOverrideValueSet"/>s /// displayed on <see cref="ElementUsage"/> <paramref name="rowThing"/>s will not have a name, as they are not interactible. /// </summary> /// <param name="rowThing"> /// The <see cref="Thing"/> of the associated row. /// </param> /// <param name="parameterValueSetBase"> /// The <see cref="ParameterValueSetBase"/> for which to generate the cell name. /// </param> /// <param name="componentIndex"> /// Optional, the <see cref="ParameterTypeComponent"/> index. /// </param> /// <returns> /// The cell name. /// </returns> private static string GetCellName(Thing rowThing, ParameterValueSetBase parameterValueSetBase, int?componentIndex = null) { // non-overrides displayed on EUs are not interactible if (rowThing is ElementUsage && parameterValueSetBase is ParameterValueSet) { return(null); } return($"{CrossviewSheetConstants.CrossviewSheetName}_{parameterValueSetBase.ModelCode(componentIndex)}"); }
/// <summary> /// Update a <see cref="ParameterValueSetBase"/> with the values from the current row or the passed <see cref="ParameterValueBaseRowViewModel"/> /// </summary> /// <param name="valueSet">The <see cref="ParameterValueSetBase"/> to update</param> /// <param name="row">The <see cref="ParameterValueBaseRowViewModel"/> containing the information, or if null the current row</param> private void UpdateScalarOrCompoundValueSet(ParameterValueSetBase valueSet, ParameterValueBaseRowViewModel row = null) { if (this.isCompoundType) { this.UpdateCompoundValueSet(valueSet, row); } else { this.UpdateScalarValueSet(valueSet, row); } }
public void TestGetOwner2() { var container = new ParameterOverride(); container.Owner = new DomainOfExpertise(); this.parameterValueSetBase = new ParameterOverrideValueSet(); container.ValueSet.Add(this.parameterValueSetBase as ParameterOverrideValueSet); Assert.IsTrue(ReferenceEquals(container.Owner, this.parameterValueSetBase.Owner)); }
/// <summary> /// Update the clone of the <see cref="ParameterValueSetBase"/> represented by this row /// </summary> /// <param name="valueset">The clone of the <see cref="ParameterValueSetBase"/> to update</param> private void UpdateValueSet(ParameterValueSetBase valueset) { if (this.ContainerViewModel is ParameterValueBaseRowViewModel parameterValueBaseRow) { parameterValueBaseRow.UpdateValueSet(valueset); } if (this.ContainerViewModel is ParameterOrOverrideBaseRowViewModel parameterOrOverrideRow) { parameterOrOverrideRow.UpdateValueSets(valueset); } }
private void SetValueSet(ParameterValueSetBase param, string value) { var stringlist = new List <string> { value }; param.Manual = new CDP4Common.Types.ValueArray <string>(stringlist); param.Reference = new CDP4Common.Types.ValueArray <string>(stringlist); param.Computed = new CDP4Common.Types.ValueArray <string>(stringlist); param.Formula = new CDP4Common.Types.ValueArray <string>(stringlist); param.ValueSwitch = ParameterSwitchKind.MANUAL; }
public void Setup() { this.booleanParameterType = new BooleanParameterType(Guid.NewGuid(), null, null) { ShortName = "bool" }; this.elementDefinition1 = new ElementDefinition(Guid.NewGuid(), null, null) { ShortName = "Sat" }; this.elementDefinition2 = new ElementDefinition(Guid.NewGuid(), null, null) { ShortName = "Bat" }; this.elementUsage = new ElementUsage(Guid.NewGuid(), null, null) { ShortName = "battery_1", ElementDefinition = this.elementDefinition2 }; this.elementDefinition1.ContainedElement.Add(this.elementUsage); this.parameter = new Parameter(Guid.NewGuid(), null, null); this.parameter.ParameterType = this.booleanParameterType; this.elementDefinition2.Parameter.Add(this.parameter); this.parameterOverride = new ParameterOverride(Guid.NewGuid(), null, null); this.parameterOverride.Parameter = this.parameter; this.parameterSubscriptionValueSet = new ParameterSubscriptionValueSet(); this.parameterValueSetBase = new ParameterValueSet(); this.parameterValueSetBase.Published = new ValueArray <string>(new List <string> { "computed" }); this.parameterValueSetBase.Computed = new ValueArray <string>(new List <string> { "computed" }); this.parameterValueSetBase.Reference = new ValueArray <string>(new List <string> { "ref" }); this.parameterValueSetBase.ActualState = new ActualFiniteState(); this.parameterValueSetBase.ActualOption = new Option(); this.parameterSubscriptionValueSet.SubscribedValueSet = this.parameterValueSetBase; this.parameterSubscriptionValueSet.Manual = new ValueArray <string>(new List <string> { "manual" }); this.parameterSubscription = new ParameterSubscription(); this.parameterSubscription.ValueSet.Add(this.parameterSubscriptionValueSet); this.parameterSubscription.Owner = new DomainOfExpertise(); }
/// <summary> /// Add the value set update listener for this row /// </summary> /// <param name="thing">The <see cref="ParameterValueSetBase"/> which updates need to be handled in this row</param> private void AddValueSetListener(ParameterValueSetBase thing) { if (this.isValueSetListenerInitialized) { return; } var listener = CDPMessageBus.Current.Listen <ObjectChangedEvent>(thing) .Where(objectChange => objectChange.EventKind == EventKind.Updated && objectChange.ChangedThing.RevisionNumber > this.RevisionNumber) .ObserveOn(RxApp.MainThreadScheduler) .Subscribe(_ => this.SetValues()); this.Disposables.Add(listener); this.isValueSetListenerInitialized = true; }
/// <summary> /// Update the clone of the <see cref="ParameterValueSetBase"/> represented by this row /// </summary> /// <param name="valueset">The clone of the <see cref="ParameterValueSetBase"/> to update</param> private void UpdateValueSet(ParameterValueSetBase valueset) { var parameterValueBaseRow = this.ContainerViewModel as ParameterValueBaseRowViewModel; if (parameterValueBaseRow != null) { parameterValueBaseRow.UpdateValueSet(valueset); } var parameterOrOverrideRow = this.ContainerViewModel as ParameterOrOverrideBaseRowViewModel; if (parameterOrOverrideRow != null) { parameterOrOverrideRow.UpdateValueSets(valueset); } }
/// <summary> /// Process the <see cref="ParameterValueSet"/> . /// </summary> /// <param name="parameterValueSet"> /// The <see cref="ParameterValueSetBase"/> to be processed. /// </param> /// <param name="parameterOrOverrideBase"> /// The <see cref="ParameterOrOverrideBase"/> the <see cref="ParameterValueSetBase"/ belongs to. /// </param> /// <param name="componentIndex"> /// The index of the <see cref="ParameterTypeComponent"/>. /// </param> /// <param name="computedValue"> /// The manual value of the <see cref="ParameterValueSet"/>. /// </param> /// <param name="processedValueSets"> /// A <see cref="Dictionary{Guid,ProcessedValueSet}"/> of ProcessedValueSe that capture the updated <see cref="Thing"/>s with its value validation result /// </param> /// <param name="provider"> /// The <see cref="IFormatProvider"/> used to validate. /// </param> /// <param name="validationErrorText"> /// <see cref="String"/> that holds the validation error text. /// </param> /// <returns> /// The added or changed <see cref="ProcessedValueSet"/> /// </returns> private ProcessedValueSet ProcessValueSet(ParameterValueSetBase parameterValueSet, ParameterOrOverrideBase parameterOrOverrideBase, int componentIndex, string computedValue, ref Dictionary <Guid, ProcessedValueSet> processedValueSets, IFormatProvider provider, out string validationErrorText) { var validationResult = ValidationResultKind.InConclusive; var switchKind = parameterValueSet.ValueSwitch; var measurementScale = parameterOrOverrideBase.Scale; var parameterType = parameterOrOverrideBase.ParameterType; validationErrorText = string.Empty; if (parameterType != null) { if (ValueSetConverter.TryParseDouble(computedValue, parameterType, out var convertedComputedValue)) { computedValue = convertedComputedValue.ToString(CultureInfo.InvariantCulture); } computedValue = computedValue?.ToValueSetObject(parameterType).ToValueSetString(parameterType) ?? parameterValueSet.Computed[componentIndex]; var validManualValue = parameterType.Validate(computedValue, measurementScale, provider); if (validManualValue.ResultKind > validationResult) { validationResult = validManualValue.ResultKind; validationErrorText = validManualValue.Message; } } var valueSetExists = processedValueSets.TryGetValue(parameterValueSet.Iid, out var processedValueSet); if (!valueSetExists) { processedValueSet = new ProcessedValueSet(parameterValueSet, validationResult); } if (processedValueSet.IsDirty(componentIndex, parameterType, switchKind, parameterValueSet.Manual[componentIndex], computedValue, parameterValueSet.Reference[componentIndex], computedValue, out var valueSetValues)) { processedValueSet.UpdateClone(valueSetValues); if (!valueSetExists) { processedValueSets.Add(parameterValueSet.Iid, processedValueSet); } } return(processedValueSet); }
/// <summary> /// Check if the current <see cref="ParameterValueSetBase"/> is publishable (the published and actual values are different) /// </summary> /// <param name="valueset">The <see cref="ParameterValueSetBase"/></param> /// <returns>True if the Published value is different from the Actual value</returns> private bool CheckValuesPublishabledStatus(ParameterValueSetBase valueset) { if (valueset == null) { return(false); } for (var i = 0; i < valueset.Published.Count(); i++) { if (valueset.Published[i] != valueset.ActualValue[i]) { return(true); } } return(false); }
/// <summary> /// Update value-set for a compound parameter. /// </summary> /// <param name="valueSet">The value set to update</param> /// <param name="row">The value row containing the information. If null the data is retrieved from the current row.</param> /// <remarks> /// If <paramref name="row"/> is null, it means the parameter is not compound, not option dependent and not state dependent. /// </remarks> private void UpdateCompoundValueSet(ParameterValueSetBase valueSet, ParameterValueBaseRowViewModel row = null) { var componentRows = (row == null) ? this.ContainedRows.Cast <ParameterComponentValueRowViewModel>().ToList() : row.ContainedRows.Cast <ParameterComponentValueRowViewModel>().ToList(); valueSet.Computed = new ValueArray <string>(new string[componentRows.Count]); valueSet.Manual = new ValueArray <string>(new string[componentRows.Count]); valueSet.Reference = new ValueArray <string>(new string[componentRows.Count]); valueSet.ValueSwitch = componentRows[0].Switch.Value; // all the switches should have the same value for (var i = 0; i < componentRows.Count; i++) { valueSet.Computed[i] = componentRows[i].Computed; valueSet.Manual[i] = componentRows[i].Manual.ToValueSetString(this.ParameterType); valueSet.Reference[i] = componentRows[i].Reference.ToValueSetString(this.ParameterType); } }
/// <summary> /// Sets the values of the <see cref="ParameterValueSetBase"/>. /// </summary> /// <param name="valueSet"> /// The valueSet. /// </param> private void SetValueSetValues(ParameterValueSetBase valueSet) { this.Value = valueSet.ActualValue.Any() ? valueSet.ActualValue.First() : "-"; this.ScaleShortName = this.Thing.Scale == null ? "-" : this.Thing.Scale.ShortName; this.Switch = valueSet.ValueSwitch; this.Formula = valueSet.Formula.Any() ? valueSet.Formula.First() : "-"; this.Computed = valueSet.Computed.Any() ? valueSet.Computed.First() : "-"; this.Manual = valueSet.Manual.Any() ? valueSet.Manual.First().ToValueSetObject(this.ParameterType) : ValueSetConverter.DefaultObject(this.ParameterType); this.Reference = valueSet.Reference.Any() ? valueSet.Reference.First().ToValueSetObject(this.ParameterType) : ValueSetConverter.DefaultObject(this.ParameterType); this.State = valueSet.ActualState == null ? "-" : valueSet.ActualState.ShortName; this.Option = valueSet.ActualOption; this.Published = valueSet.Published.Any() ? valueSet.Published.First() : "-"; }
/// <summary> /// Update value-set for a not-compound parameter. /// </summary> /// <param name="valueSet">The value set to update</param> /// <param name="row">The value row containing the information. If null the data is retrieved from the current row.</param> /// <remarks> /// If <paramref name="row"/> is null, it means the parameter is not compound, not option dependent and not state dependent. /// </remarks> private void UpdateScalarValueSet(ParameterValueSetBase valueSet, ParameterValueBaseRowViewModel row = null) { valueSet.ValueSwitch = row == null ? this.Switch.Value : row.Switch.Value; valueSet.Computed = row == null ? new ValueArray <string>(new List <string> { this.Computed }) : new ValueArray <string>(new List <string> { row.Computed }); valueSet.Manual = row == null ? new ValueArray <string>(new List <string> { this.Manual.ToValueSetString(this.ParameterType) }) : new ValueArray <string>(new List <string> { row.Manual.ToValueSetString(this.ParameterType) }); valueSet.Reference = row == null ? new ValueArray <string>(new List <string> { this.Reference.ToValueSetString(this.ParameterType) }) : new ValueArray <string>(new List <string> { ValueSetConverter.ToValueSetString(row.Reference, this.ParameterType) }); }
/// <summary> /// The method that performs the necessary calculations and and returns the <see cref="RequirementStateOfCompliance"/> based on those calculations /// </summary> /// <param name="valueSet">The <see cref="ParameterValueSetBase"/> that is used for calculations</param> /// <param name="relationalExpression">The <see cref="RelationalExpression"/> that is used for calculations</param> /// <returns><see cref="RequirementStateOfCompliance"/> based on the calculations</returns> public RequirementStateOfCompliance Calculate(ParameterValueSetBase valueSet, RelationalExpression relationalExpression) { var comparer = this.GetValueSetComparer(relationalExpression); switch (relationalExpression.RelationalOperator) { case RelationalOperatorKind.EQ: return(comparer.Compare(valueSet.ActualValue, relationalExpression.Value) == 0 ? RequirementStateOfCompliance.Pass : RequirementStateOfCompliance.Failed); case RelationalOperatorKind.GE: return(comparer.Compare(valueSet.ActualValue, relationalExpression.Value) >= 0 ? RequirementStateOfCompliance.Pass : RequirementStateOfCompliance.Failed); case RelationalOperatorKind.GT: return(comparer.Compare(valueSet.ActualValue, relationalExpression.Value) > 0 ? RequirementStateOfCompliance.Pass : RequirementStateOfCompliance.Failed); case RelationalOperatorKind.LE: return(comparer.Compare(valueSet.ActualValue, relationalExpression.Value) <= 0 ? RequirementStateOfCompliance.Pass : RequirementStateOfCompliance.Failed); case RelationalOperatorKind.LT: return(comparer.Compare(valueSet.ActualValue, relationalExpression.Value) < 0 ? RequirementStateOfCompliance.Pass : RequirementStateOfCompliance.Failed); case RelationalOperatorKind.NE: return(comparer.Compare(valueSet.ActualValue, relationalExpression.Value) != 0 ? RequirementStateOfCompliance.Pass : RequirementStateOfCompliance.Failed); default: throw new ArgumentOutOfRangeException(nameof(relationalExpression.RelationalOperator), relationalExpression.RelationalOperator, $"Unknown {nameof(relationalExpression.RelationalOperator)}"); } }
/// <summary> /// Gets the column index associated to the given <paramref name="parameterValueSetBase"/> /// </summary> /// <param name="parameterValueSetBase"> /// The given <see cref="ParameterValueSetBase"/> /// </param> /// <param name="component"> /// The given <see cref="ParameterTypeComponent"/> /// </param> /// <returns> /// The column index /// </returns> internal int GetContentColumnIndex(ParameterValueSetBase parameterValueSetBase, ParameterTypeComponent component = null) { var parameterOrOverrideBase = (ParameterOrOverrideBase)parameterValueSetBase.Container; if (component != null) { return(this.GetContentColumnIndex(( parameterOrOverrideBase.ParameterType.ShortName, component.ParameterType.ShortName, component.Scale?.ShortName ?? "", parameterValueSetBase.ActualOption?.ShortName ?? "", parameterOrOverrideBase.StateDependence?.ShortName ?? "", parameterValueSetBase.ActualState?.ShortName ?? ""))); } return(this.GetContentColumnIndex(( parameterOrOverrideBase.ParameterType.ShortName, "", parameterOrOverrideBase.Scale?.ShortName ?? "", parameterValueSetBase.ActualOption?.ShortName ?? "", parameterOrOverrideBase.StateDependence?.ShortName ?? "", parameterValueSetBase.ActualState?.ShortName ?? ""))); }
/// <summary> /// Set the value of this row in case of the <see cref="ParameterType"/> is a <see cref="SampledFunctionParameterType"/> /// </summary> /// <param name="valueSet">The <see cref="ParameterValueSetBase"/> containing the value</param> public void SetSampledFunctionValue(ParameterValueSetBase valueSet) { // perform checks to see if this is indeed a scalar value if (valueSet.Published.Count() < 2) { logger.Warn("The value set of Parameter or override {0} is marked as SampledFunction, yet has less than 2 values.", this.Thing.Iid); } this.Switch = valueSet.ValueSwitch; var samplesFunctionParameterType = this.Thing.ParameterType as SampledFunctionParameterType; if (samplesFunctionParameterType == null) { logger.Warn("ParameterType mismatch, in {0} is marked as SampledFunction, yet cannot be converted.", this.Thing.Iid); this.Value = "-"; return; } var cols = samplesFunctionParameterType.NumberOfValues; this.Value = $"[{valueSet.Published.Count / cols}x{cols}]"; }
/// <summary> /// Creates a <see cref="NestedParameter"/> based on the provided <see cref="ParameterOrOverrideBase"/> and <see cref="ParameterValueSetBase"/> /// </summary> /// <param name="parameter"> /// The <see cref="ParameterOrOverrideBase"/> that contains the <see cref="ParameterValueSetBase"/> based on which the /// <see cref="NestedParameter"/> is created. /// </param> /// <param name="component"> /// The <see cref="ParameterTypeComponent"/> that this <see cref="NestedParameter"/> is associated to. This may be null in case the <see cref="ParameterType"/> /// of the associated <see cref="Parameter"/> is a <see cref="ScalarParameterType"/>. /// </param> /// <param name="valueSet"> /// The <see cref="ParameterValueSetBase"/> that provides the reference to the <see cref="ActualFiniteState"/> and values /// to create the <see cref="NestedParameter"/> /// </param> /// <param name="option"> /// The <see cref="Option"/> for which the <see cref="NestedParameter"/> is created. /// </param> /// <returns> /// An instance of a non-volatile <see cref="NestedParameter"/> /// </returns> private NestedParameter CreatedNestedParameter(ParameterOrOverrideBase parameter, ParameterTypeComponent component, ParameterValueSetBase valueSet, Option option) { var componentIndex = component == null ? 0 : component.Index; var actualValue = valueSet.ActualValue[componentIndex]; var formula = valueSet.Formula[componentIndex]; var nestedParameter = new NestedParameter(Guid.NewGuid(), parameter.Cache, parameter.IDalUri) { IsVolatile = true, AssociatedParameter = parameter, Owner = parameter.Owner, Component = component, ActualState = valueSet.ActualState, ActualValue = actualValue, Formula = formula, ValueSet = valueSet, Option = option }; return(nestedParameter); }
public void Setup() { this.parameterValueSetBase = new ParameterValueSet(); }