/// <summary>
/// Set raw values
/// </summary>
/// <param name="values">values</param>
public void SetValues(IEnumerable <byte> values)
{
// clear values
Values.Clear();
// add values
Values.AddRange(values);
}
public BenchThreadParams(ISimpleDictionary simpleDictionary, int stepDelay, List <int> values, bool workloadWrite)
{
SimpleDictionary = simpleDictionary;
StepDelay = stepDelay;
Values.AddRange(values);
WorkloadWrite = workloadWrite;
}
public Rule(string raw)
{
var elements = raw.Split(':');
Name = elements[0].Trim();
Values.AddRange(elements[1].Split("or").Select(e => e.Trim()));
}
public InList(ISqlExpression exp1, bool isNot, params ISqlExpression[] values)
: base(exp1, isNot, SqlQuery.Precedence.Comparison)
{
if (values != null && values.Length > 0)
{
Values.AddRange(values);
}
}
public InList(ISqlExpression exp1, bool isNot, IEnumerable <ISqlExpression> values)
: base(exp1, isNot, SqlQuery.Precedence.Comparison)
{
if (values != null)
{
Values.AddRange(values);
}
}
public void Load(SettingsStorage storage)
{
Name = storage.GetValue <string>("Name");
Number = storage.GetValue <int>("Number");
Values.AddRange(storage.GetValue <SettingsStorage[]>("Values").Select(s => s.Load <ImportEnumMappingWindow.MappingValue>()));
DefaultValue = storage.GetValue <object>("DefaultValue");
Format = storage.GetValue <string>("Format");
}
/// <summary>
/// Create an argument with an optional array of values
/// </summary>
///
/// <param name="name">The argument name</param>
/// <param name="values">The array of values</param>
public ShellArgument(string name, IEnumerable <string> values)
{
Name = name;
if (values != null)
{
Values.AddRange(values);
}
}
/// <summary>
/// Load settings.
/// </summary>
/// <param name="storage">Settings storage.</param>
public void Load(SettingsStorage storage)
{
Name = storage.GetValue <string>(nameof(Name));
IsExtended = storage.GetValue <bool>(nameof(IsExtended));
//Number = storage.GetValue<int>(nameof(Number));
Values.AddRange(storage.GetValue <SettingsStorage[]>(nameof(Values)).Select(s => PersistableHelper.Load <FieldMappingValue>(s)));
DefaultValue = storage.GetValue <string>(nameof(DefaultValue));
Format = storage.GetValue <string>(nameof(Format));
IsEnabled = storage.GetValue(nameof(IsEnabled), IsEnabled);
}
private void DrawChart()
{
if (Spectrum != null)
{
Values.Clear();
Values.AddRange(Spectrum.Skip(1).Select(v => new ObservableValue(v)).ToList());
Labels.Clear();
Labels.AddRange(FreqSpan?.Skip(1).Select(x => x.ToString()).ToArray());
}
}
public ReportParameter(string name, string[] values, bool visible)
{
Name = name;
if (values == null)
{
throw new ArgumentNullException("values");
}
Values.AddRange(values);
Visible = visible;
}
public ArrayValue(params string[] args)
{
if (args != null)
{
Values.AddRange(args);
}
else
{
Values.Add(null);
}
}
//private string[] lab;
private void Update()
{
double[] stock = InfoArticulos.valoresStock;
IEnumerable <double> m = stock;
Values.AddRange(m);
Lab.AddRange(InfoArticulos.valoresFecha);
Chart.Update(true);
//DataContext = this;
//lab = InfoArticulos.valoresFecha;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="pJunctionOperator"></param>
/// <param name="pValueOperator"></param>
/// <param name="pValues"></param>
public Filter(JunctionOperator pJunctionOperator,
ValueOperator pValueOperator,
params T[] pValues)
{
_junctionOperator = pJunctionOperator;
_valueOperator = pValueOperator;
if (pValues != null)
{
Values.AddRange(pValues);
}
}
public void Deserialize(NomadObject root)
{
var values = root.GetChild(ValuesId);
var fixups = root.GetChild(FixupsId);
if (values != null)
{
Values.AddRange(values.Children);
}
if (fixups != null)
{
ReadFixups(fixups);
}
}
public EnumTypeAnalyzer(INamedTypeSymbol type, params object[] values)
{
Type = type;
if (Type != null)
{
Fields.AddRange(Type.GetMembers().Where(m => m.Kind == SymbolKind.Field).Cast <IFieldSymbol>());
_Symbols = Fields.ToDictionary(field => field.ConstantValue);
Values.AddRange(values.Select(val => _Symbols[val]));
}
else
{
Values.AddRange(values.Cast <IFieldSymbol>());
}
}
protected override void OnClick()
{
base.OnClick();
var wnd = new ImportEnumMappingWindow {
EnumType = EnumType
};
wnd.Values.AddRange(Values.Select(v => v.Clone()));
wnd.Title = wnd.Title.Put(FieldName);
if (!wnd.ShowModal(this))
{
return;
}
Values.Clear();
Values.AddRange(wnd.Values);
RefreshTitle();
}
private void AddValues(object filter)
{
if (filter == null)
{
return;
}
else if (filter is string)
{
Values.Add(filter);
}
else if (filter is IEnumerable <string> || filter is IEnumerable <object> )
{
IEnumerable <object> filterValues = filter as IEnumerable <string>;
filterValues = filterValues == null ? filter as IEnumerable <object> : filterValues;
Values.AddRange(filterValues);
}
else
{
Values.Add(filter);
}
}
public SourceTableSliceTestAggregation(IEnumerable <SourceTableSliceTest> input)
{
foreach (var i in input)
{
Count++;
if (format == SourceTableSliceType.undefined)
{
format = i.format;
}
ValueCountRange.Learn(i.Values.Count);
Values.AddRange(i.Values);
IsUniformFormat &= i.IsUniformFormat;
IsDistinctValue &= i.IsDistinctValue;
IsNoEmptyValue &= i.IsNoEmptyValue;
if (i.IsUniformFormat)
{
IsUniformFormatCounter++;
}
if (i.IsDistinctValue)
{
IsDistinctValueCounter++;
}
if (i.IsNoEmptyValue)
{
IsNoEmptyCounter++;
}
}
DistinctValues = Values.GetUnique();
// IsUniformFormat = //IsUniformFormatCounter == Count;
// IsDistinctValue = IsDistinctValueCounter == Count;
// IsNoEmptyValue = IsNoEmptyCounter == Count;
}
public object Convert(IList <object> values, Type targetType, object parameter, CultureInfo culture)
{
Values.AddRange(values);
return(values.FirstOrDefault());
}
public SensorDataValue(DateTimeOffset time, IEnumerable <T> values)
{
Date = time.ToUnixTimeMilliseconds();
Values.AddRange(values);
}
internal void RestorePruned()
{
Values.AddRange(Pruned);
Pruned.Clear();
}
internal void RestoreGuess()
{
Values.AddRange(RemovedByGuess);
RemovedByGuess.Clear();
}
public SelectElementBuilder AddValues(string value, params string[] values)
{
Values.Add(value);
Values.AddRange(values);
return(this);
}
public MenuDetails(IEnumerable <Types.MenuDetail> values)
{
Values.AddRange(values);
}
/// <summary>
/// Adds the elements of the specified array to the end of the <see cref="IColList"/>.
/// </summary>
/// <param name="values">The array whose elements should be added to the end of the
/// <see cref="IColList"/>.</param>
public override void Add(params Expression <Func <object> >[] values)
{
Values.AddRange(values.Select(x => SqlBuilder.Instance.Col(x)));
}
public OutputRow(params object[] values)
{
Values.AddRange(values ?? new object[0]);
}
public void Merge(ParameterValues parameterValues)
{
Values.AddRange(parameterValues.Values);
Percentiles.AddRange(parameterValues.Percentiles);
}
/// <summary>
/// Adds the elements of the specified collection to the end of the <see cref="IColList"/>.
/// </summary>
/// <param name="values">The collection whose elements should be added to the end of the
/// <see cref="IColList"/>.</param>
public override void Add(IEnumerable <Expression <Func <object> > > values)
{
Values.AddRange(values.Select(x => SqlBuilder.Instance.Col(x)));
}
internal override void parse(string str, ref int pos, ReleaseVersion release, int len, ConcurrentDictionary <int, BaseClassIfc> dictionary)
{
base.parse(str, ref pos, release, len, dictionary);
Values.AddRange(ParserSTEP.StripListLink(str, ref pos, len).ConvertAll(x => dictionary[x] as IfcIrregularTimeSeriesValue));
}
public SelectElementBuilder AddValues(IEnumerable <string> values)
{
Values.AddRange(values);
return(this);
}