private bool CheckConsistencyRange(IInspectInstruction node, ISealableDictionary <IFeatureName, IDiscrete> enforcedDiscreteTable)
{
bool Success = true;
IList <IConstantRange> CompleteRangeList = new List <IConstantRange>();
foreach (IWith WithItem in node.WithList)
{
foreach (IRange RangeItem in WithItem.RangeList)
{
IConstantRange ResolvedRange = RangeItem.ResolvedRange.Item;
if (IsRangeCompatible(CompleteRangeList, ResolvedRange))
{
if (enforcedDiscreteTable != null && !IsRangeValidDiscrete(enforcedDiscreteTable, ResolvedRange))
{
AddSourceError(new ErrorInvalidRange(RangeItem));
Success = false;
}
else
{
CompleteRangeList.Add(ResolvedRange);
}
}
else
{
AddSourceError(new ErrorInvalidRange(RangeItem));
Success = false;
}
}
}
return(Success);
}
/// <summary>
/// Tries to parse a range node to obtain the corresponding range of constants.
/// </summary>
/// <param name="range">The range to parse.</param>
/// <param name="result">The constant range upon return if successful.</param>
/// <param name="error">The error in case of failure.</param>
public static bool TryParseRange(IRange range, out IConstantRange result, out IError error)
{
result = null;
IOrderedLanguageConstant LeftExpressionConstant;
IOrderedLanguageConstant RightExpressionConstant;
if (!LanguageConstant.TryParseExpression((IExpression)range.LeftExpression, out LeftExpressionConstant, out error))
{
return(false);
}
if (!range.RightExpression.IsAssigned)
{
RightExpressionConstant = LeftExpressionConstant;
}
else if (!LanguageConstant.TryParseExpression((IExpression)range.RightExpression.Item, out RightExpressionConstant, out error))
{
return(false);
}
if (!LeftExpressionConstant.IsCompatibleWith(RightExpressionConstant))
{
error = new ErrorIncompatibleRangeBounds(range);
return(false);
}
result = new ConstantRange(LeftExpressionConstant, RightExpressionConstant);
error = null;
return(true);
}
private bool IsRangeCompatible(IList <IConstantRange> completeRangeList, IConstantRange range)
{
bool IsIntersecting = false;
foreach (IConstantRange Item in completeRangeList)
{
IsIntersecting |= Item.IsIntersecting(range);
}
return(!IsIntersecting);
}
/// <summary>
/// Checks if two ranges intersect.
/// </summary>
/// <param name="other">The other range.</param>
public bool IsIntersecting(IConstantRange other)
{
if (!Minimum.IsCompatibleWith(other.Maximum) || !other.Minimum.IsCompatibleWith(Maximum))
{
return(false);
}
if (Minimum.IsConstantGreater(other.Maximum) || other.Minimum.IsConstantGreater(Maximum))
{
return(false);
}
return(true);
}
private void AddValueToList(IConstantRange range)
{
if (LanguageConstant.TryParseInt(range.Minimum, out int IntMinimum) && LanguageConstant.TryParseInt(range.Maximum, out int IntMaximum))
{
ConstantList.Add(range.Minimum);
if (IntMinimum < IntMaximum)
{
for (int i = IntMinimum + 1; i < IntMaximum; i++)
{
ConstantList.Add(new NumberLanguageConstant(new Number(i)));
}
ConstantList.Add(range.Maximum);
}
}
else if (range.Minimum is DiscreteLanguageConstant AsDiscreteMinimum && AsDiscreteMinimum.IsValueKnown && range.Maximum is DiscreteLanguageConstant AsDiscreteMaximum && AsDiscreteMaximum.IsValueKnown)
{
ConstantList.Add(AsDiscreteMinimum);
if (AsDiscreteMaximum.IsConstantGreater(AsDiscreteMinimum))
{
IClass EmbeddingClass = AsDiscreteMinimum.Discrete.EmbeddingClass;
int DiscreteMinimumIndex = EmbeddingClass.DiscreteList.IndexOf(AsDiscreteMinimum.Discrete);
int DiscreteMaximumIndex = EmbeddingClass.DiscreteList.IndexOf(AsDiscreteMaximum.Discrete);
if (DiscreteMinimumIndex >= 0 && DiscreteMaximumIndex >= 0)
{
for (int Index = DiscreteMinimumIndex + 1; Index < DiscreteMaximumIndex; Index++)
{
IDiscrete MiddleDiscrete = EmbeddingClass.DiscreteList[Index];
DiscreteLanguageConstant MiddleConstant = new DiscreteLanguageConstant(MiddleDiscrete);
ConstantList.Add(MiddleConstant);
}
}
}
}
}
private bool IsRangeValidDiscrete(ISealableDictionary <IFeatureName, IDiscrete> discreteTable, IConstantRange constantRange)
{
bool IsValidRange = false;
if (constantRange.Minimum is IDiscreteLanguageConstant AsMinimum && AsMinimum.IsValueKnown && constantRange.Maximum is IDiscreteLanguageConstant AsMaximum && AsMaximum.IsValueKnown)
{
bool IsValidMinimum = false;
bool IsValidMaximum = false;
foreach (KeyValuePair <IFeatureName, IDiscrete> Entry in discreteTable)
{
if (AsMinimum.Discrete == Entry.Value)
{
IsValidMinimum = true;
}
if (AsMaximum.Discrete == Entry.Value)
{
IsValidMaximum = true;
}
}
IsValidRange |= IsValidMinimum && IsValidMaximum;
}
return(IsValidRange);
}