public ArrayVariant([NotNull] Variable value, [NotNull] AnalysisContext context) : base(value, context)
{
Value = new DataValueArray(Array.Empty <LogicExpressionBase>());
IndexRange = ValueInterval.Empty;
if (!(value.TypeRef is ArrayTypeRef arrayTypeRef))
{
Log.Error("ArrayVariant expects ArrayTypeRef, not {Type}", value.TypeRef);
return;
}
if (!(arrayTypeRef.Length is OrderedLiteralBase length))
{
Log.Information("ArrayVariant expects OrderedLiteralBase as length, not {Type}",
arrayTypeRef.Length);
return;
}
IndexRange = new ValueInterval(IntegerLiteral.Zero, length, toInclusive: false);
foreach (var i in IndexRange.Iterate(IntegerLiteral.One))
{
var itemVariant = new ArrayItemVariant(value,
InnerTypeRef,
ValueInterval.Single(i),
context);
this[context, i] = itemVariant;
}
}
public void SetRange2(double left, double right)
{
AssertValidRange(left, right);
Value2Left = left;
Value2Right = right;
v2Direction = right > left;
reverseMap = IsSameDirection();
Range2 = ValueInterval.CloseClose(Math.Min(right, left), Math.Max(right, left));
CalculateRatos();
}
public CombinedItemVariant([NotNull] IDataValue value, [NotNull] Variable arrayStorage,
[NotNull] TypeReference typeRef, [NotNull] ValueInterval index,
[NotNull] IReadOnlyList <ItemValueVariantBase> source, [NotNull] AnalysisContext context)
: base(arrayStorage, typeRef, context)
{
Index = index ?? throw new ArgumentNullException(nameof(index));
Value = value ?? throw new ArgumentNullException(nameof(value));
Values = source ?? throw new ArgumentNullException(nameof(source));
if (source.Count == 0)
{
throw new ArgumentException("Value cannot be an empty collection.", nameof(source));
}
}
/// <summary>
/// パネルのロード時
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void NumberOfRowsInputDialog_Load(object sender, EventArgs e)
{
InputNum = 0;
//int max = int.Parse(AppObject.CommonConfDic[MESConsts.MaxAppendRowCount].ToString());
ValueInterval vi = new ValueInterval(1, MaxCount, true, true);
vi.UseMinValue = true;
vi.UseMaxValue = true;
this.RowNumericEdit.PostValidation.Intervals.Add(vi);
this.RowNumericEdit.MaxLength = CommonConsts.C1NumericEditMaxLength;
this.RowNumericEdit.ErrorInfo.ErrorMessage = _mlu.GetMsg(CommonConsts.MSG_OUT_OF_BOUND);
this.RowNumericEdit.ErrorInfo.ErrorMessageCaption = _mlu.GetMsg(CommonConsts.TITLE_ERROR);
}
public IEnumerable <ItemValueVariantBase> this[[NotNull] AnalysisContext context,
[CanBeNull] ValueInterval interval]
{
get
{
if (interval != null)
{
interval &= IndexRange;
}
else
{
interval = IndexRange;
}
foreach (var i in interval.Iterate(IntegerLiteral.One))
{
yield return(this[context, i]);
}
}
set
{
if (interval != null)
{
interval &= IndexRange;
}
else
{
interval = IndexRange;
}
var indexes = interval.Iterate(IntegerLiteral.One);
var values = value;
var indexesArray = indexes.ToArray();
var valuesArray = values.ToArray();
if (indexesArray.Length != valuesArray.Length)
{
Log.Warning("Mismatch: {Indexes} = {Values}", indexesArray, valuesArray);
}
indexes = indexesArray;
values = valuesArray;
foreach (var(i, item) in indexes.Zip(values))
{
this[context, i] = item;
}
}
}
public ValueMapper(double value1Left, double value1Right, double value2Left, double value2Right)
{
Value1Left = value1Left;
Value2Left = value2Left;
Value1Right = value1Right;
Value2Right = value2Right;
//如果两组数据的left-->right的方向不一样，则作对称映射
//不用考虑相等的情况，如果left和right相等，new ValueRange会抛出异常
v1Direction = value1Right > value1Left;
v2Direction = value2Right > value2Left;
reverseMap = IsSameDirection();
Range1 = ValueInterval.CloseClose(Math.Min(value1Right, value1Left), Math.Max(value1Right, value1Left));
Range2 = ValueInterval.CloseClose(Math.Min(value2Right, value2Left), Math.Max(value2Right, value2Left));
CalculateRatos();
}
public ArrayItemVariant([NotNull] Variable arrayStorage, [NotNull] TypeReference typeRef,
[NotNull] ValueInterval index, [NotNull] AnalysisContext context)
: base(arrayStorage, typeRef, context)
{
Index = index ?? throw new ArgumentNullException(nameof(index));
Value = new DataValueUnknown();
switch (typeRef)
{
case PrimitiveTypeRef primitiveTypeRef:
var defaultValue = primitiveTypeRef.DefaultValue;
if (defaultValue is OrderedLiteralBase defaultOrderedValue)
{
Value = new DataValueInterval(ValueInterval.Single(defaultOrderedValue),
Array.Empty <LogicExpressionBase>());
}
break;
default:
throw new ArgumentOutOfRangeException(nameof(typeRef));
}
}
public DoubleStrInRange(double max, double min) : this(ValueInterval.CloseClose(max, min))
{
}
public DoubleStrInRange(ValueInterval interval) : base(@"^[0-9]*\.?[0-9]+")
{
this.interval = interval;
}
public IntStrInRange(int max, int min) : this(ValueInterval.CloseClose(max, min))
{
}
public IntStrInRange(ValueInterval interval) : base(@"^[+]{0,1}(\d+)$")
{
this.interval = interval;
}
public IntStrInRange(int min, int max) : this(ValueInterval.CloseClose(min, max))
{
}
public DoubleStrInRange(ValueInterval interval) : base(@"^[+-]*[0-9]+(\.[0-9]{1,2})?$")
{
this.interval = interval;
}
public DoubleStrInRange(double min, double max) : this(ValueInterval.CloseClose(min, max))
{
}
public DataValueInterval([NotNull] ValueInterval interval,
[NotNull][ItemNotNull] IReadOnlyList <LogicExpressionBase> constraints)
{
Interval = interval ?? throw new ArgumentNullException(nameof(interval));
Constraints = constraints ?? throw new ArgumentNullException(nameof(constraints));
}
