public bool IsValid(T toCheck)
{
if (MinimumSet)
{
var comparison = Minimum.CompareTo(toCheck);
if (comparison < 0)
{
return(true);
}
if (IncludeMinimumEqual && comparison == 0)
{
return(true);
}
}
if (MaximumSet)
{
var comparison = Maximum.CompareTo(toCheck);
if (comparison > 0)
{
return(false);
}
if (IncludeMaximumEqual && comparison == 0)
{
return(true);
}
}
return(false);
}
public int CompareTo(Range <T> range)
{
if (Value.CompareTo(range.Value) != 0)
{
return(Value.CompareTo(range.Value));
}
if (Minimum.CompareTo(range.Minimum) != 0)
{
return(Minimum.CompareTo(range.Minimum));
}
if (Maximum.CompareTo(range.Maximum) != 0)
{
return(Maximum.CompareTo(range.Maximum));
}
if (MinimumBoundary != range.MinimumBoundary)
{
return(MinimumBoundary.CompareTo(range.Minimum));
}
if (MaximumBoundary != range.MaximumBoundary)
{
return(MaximumBoundary.CompareTo(range.MaximumBoundary));
}
return(0);
}
protected override bool ConditionApplies(ModelInstance root)
{
object value = root[Property];
if (value == null || (value is double && double.IsNaN((double)value)))
{
return(false);
}
// min <= value <= max
// CompareTo = 0: equal, >0: instance > value
if (Minimum != null && Maximum != null)
{
return(Minimum.CompareTo(value) > 0 && Maximum.CompareTo(value) < 0);
}
else if (Minimum != null)
{
return(Minimum.CompareTo(value) > 0);
}
else if (Maximum != null)
{
return(Maximum.CompareTo(value) < 0);
}
else
{
return(false);
}
}
public bool Equals(Range <T> range)
{
return((Value.CompareTo(range.Value) == 0) &&
(Minimum.CompareTo(range.Minimum) == 0) &&
(Maximum.CompareTo(range.Maximum) == 0) &&
(MinimumBoundary == range.MinimumBoundary) &&
(MaximumBoundary == range.MaximumBoundary));
}
private void UpdateNotificationText()
{
if (userDefinedNotificationText)
{
return;
}
string sign;
if (!this.IsInitial(MinimumProperty) && Minimum.CompareTo(default(T)) >= 0)
{
sign = "positive";
}
else if (!this.IsInitial(MinimumProperty) && Minimum.CompareTo(default(T)) < 0)
{
sign = "negative";
}
else
{
sign = null;
}
string numberTypeName;
if (numberType == NumberType.Integer)
{
numberTypeName = "integer";
}
else
{
numberTypeName = "decimal number";
}
string phrase;
string article;
if (sign != null)
{
phrase = "a " + sign + " " + numberTypeName;
}
else
{
if (numberType == NumberType.Integer)
{
article = "an";
}
else
{
article = "a";
}
phrase = article + " " + numberTypeName;
}
notificationTextModified = true;
NotificationText = "Invalid input\nPlease enter " + phrase;
}
public void Join(T value)
{
if (Minimum.CompareTo(value) > 0)
{
Minimum = value;
}
if (Maximum.CompareTo(value) < 0)
{
Maximum = value;
}
}
public int CompareTo(double item)
{
if (Minimum.CompareTo(item) > 0)
{
return(-1);
}
if (Maximum.CompareTo(item) < 0)
{
return(1);
}
return(0);
}
/// <summary>
/// Updates the minimum value in the range if the proposed value is less than the current minimum value.
/// </summary>
/// <param name="proposedMin">New candidate value for the minimum.</param>
public void UpdateMinimum(T proposedMin)
{
if (_minValid)
{
if (Minimum.CompareTo(proposedMin) > 0)
{
Minimum = proposedMin;
}
}
else
{
Minimum = proposedMin;
}
}
public virtual T Clamp(T value)
{
if (Minimum.CompareTo(value) > 0)
{
return(Minimum);
}
else if (Maximum.CompareTo(value) < 0)
{
return(Maximum);
}
else
{
return(value);
}
}
protected override void OnPreviewTextInput(TextCompositionEventArgs e)
{
base.OnPreviewTextInput(e);
if (e.Handled)
{
return;
}
if (e.Text == "-")
{
e.Handled = true;
int newCaretIndex;
if (Text.StartsWith("-") && (this.IsInitial(MaximumProperty) || Maximum.CompareTo(default(T)) >= 0))
{
newCaretIndex = Math.Max(0, CaretIndex - 1);
Text = Text.Substring(1);
}
else if ((this.IsInitial(MinimumProperty) || Minimum.CompareTo(default(T)) < 0))
{
newCaretIndex = CaretIndex + 1;
Text = Text.Insert(0, "-");
}
else
{
ShowNotification();
return;
}
CaretIndex = newCaretIndex;
}
else if (e.Text == DECIMAL_SEPARATOR)
{
if (Text.Contains(DECIMAL_SEPARATOR))
{
e.Handled = true;
ShowNotification();
}
else if (Text == string.Empty)
{
e.Handled = true;
Text = "0" + DECIMAL_SEPARATOR;
CaretIndex = Text.Length;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Range{T}"/> class.
/// </summary>
/// <param name="min"></param>
/// <param name="max"></param>
public Range(T min, T max)
{
if (min == null)
{
throw new ArgumentNullException();
}
if (max == null)
{
throw new ArgumentNullException();
}
if (Minimum.CompareTo(Maximum) > 0)
{
throw new ArgumentException("Minimum value must be less than or equal to the maximum value.");
}
Minimum = min;
Maximum = max;
}
protected override bool ConditionApplies(ModelInstance root)
{
int value = root.GetList((ModelReferenceProperty)Property).Count;
if (Minimum > 0 && Maximum > 0)
{
return(Minimum.CompareTo(value) > 0 && Maximum.CompareTo(value) < 0);
}
else if (Minimum > 0)
{
return(Minimum.CompareTo(value) > 0);
}
else if (Maximum > 0)
{
return(Maximum.CompareTo(value) < 0);
}
else
{
return(false);
}
}
/// <summary>
/// Returns whether or not the specified <paramref name="value" /> exists within the bounds of the range.
/// </summary>
/// <param name="value">The value.</param>
/// <returns>
/// True if <paramref name="value" /> exists within the range.
/// </returns>
public virtual bool Contains(T value)
{
return Minimum.CompareTo(value) <= 0 && Maximum.CompareTo(value) >= 0;
}
private bool IsValid()
{
return(Minimum.CompareTo(Maximum) <= 0);
}
/// <summary>
/// Determines if the provided value is inside the range.
/// </summary>
/// <param name="value">The value to test.</param>
/// <returns><c>true</c> if the value is inside Range, otherwise <c>false</c>.</returns>
public bool IsValueInRange(T value)
{
return((Minimum.CompareTo(value) <= 0) && (value.CompareTo(Maximum) <= 0));
}
///<inheritdoc cref="IRangify{T}"/>
public bool IsValid() => Minimum.CompareTo(Maximum) <= 0;
public bool IsValid()
{
return(Minimum.CompareTo(Maximum) <= 0);
}
protected virtual bool IsValid()
{
return(Minimum.CompareTo(Maximum) > 0);
}
public bool Contains(T value)
{
return(Minimum.CompareTo(value) <= 0 && Maximum.CompareTo(value) >= 0);
}
/// <summary> /// Determines whether the specified <paramref name="minimum" /> and <paramref name="maximum" /> values are equal to /// this instance values. /// </summary> /// <param name="minimum">The minimum value.</param> /// <param name="maximum">The maximum value.</param> /// <returns> /// <c>true</c> if the specified <paramref name="minimum" /> and <paramref name="maximum" /> values are equal to this /// instance values; otherwise, <c>false</c>. /// </returns> public bool Equals(T?minimum, T?maximum) => Minimum?.CompareTo(minimum) == 0 && Maximum?.CompareTo(maximum) == 0;
/// <summary>
/// Determines if the provided value is inside the range
/// </summary>
/// <param name="value">The value to test</param>
/// <returns>True if the value is inside Range, else false</returns>
public Boolean ContainsValue(TNumeric value)
{
return((Minimum.CompareTo(value) <= 0) && (value.CompareTo(Maximum) <= 0));
}
/// <summary>
/// Determines if the range is valid
/// </summary>
/// <returns>True if range is valid, else false</returns>
public Boolean IsValid()
{
return(Minimum.CompareTo(Maximum) <= 0);
}
/// <summary>
/// Presents the Range in readable format
/// </summary>
/// <returns>String representation of the Range</returns>
public override string ToString()
{
return(Minimum.CompareTo(Maximum) == 0 ? Minimum.ToString() : $"{Minimum} - {Maximum}");
}
/// <summary> /// Determines if the provided value is inside the range /// </summary> /// <param name="value">The value to test</param> /// <returns>True if the value is inside Range, else false</returns> public Boolean IsBetweenLimits(T value) => (Minimum.CompareTo(value) < 0) && (value.CompareTo(Maximum) < 0);
/// <summary>
/// Checks to see if this range is a proper sub range of another range (inclusive)
/// </summary>
/// <param name="other">The other range to compare to</param>
/// <returns>True if this range is fully enclosed by the other range, false otherwise</returns>
public bool IsSubRange(DoubleRange other)
{
return(Maximum.CompareTo(other.Maximum) <= 0 && Minimum.CompareTo(other.Minimum) >= 0);
}
/// <summary>
/// Checks to see if this range overlaps another range (inclusive)
/// </summary>
/// <param name="other">The other range to compare to</param>
/// <returns>True if the other range in any way overlaps this range, false otherwise</returns>
public bool IsOverlapping(DoubleRange other)
{
return(Maximum.CompareTo(other.Minimum) >= 0 && Minimum.CompareTo(other.Maximum) <= 0);
}
public bool ContainsValue(T value)
{
return((Minimum.CompareTo(value) <= 0) && (value.CompareTo(Maximum) <= 0));
}
/// <summary>Determines if the given value is within the range, inclusive.</summary>
/// <param name="in_value">The value to test.</param>
/// <returns><c>true</c>, if the value is in range, <c>false</c> otherwise.</returns>
public bool ContainsValue(T in_value)
{
return(Minimum.CompareTo(in_value) <= 0 && Maximum.CompareTo(in_value) >= 0);
}
///<inheritdoc cref="IRangify{T}"/>
public bool ContainsValue(T value) => Minimum.CompareTo(value) <= 0 && value.CompareTo(Maximum) <= 0;
/// <summary>
/// Returns a <see cref="string" /> that represents this instance.
/// </summary>
/// <param name="format">
/// A composite format string for a single value (minimum and maximum are equal). Use {0} for the
/// minimum and {1} for the maximum value.
/// </param>
/// <param name="formatRange">
/// A composite format string for the range values. Use {0} for the minimum and {1} for the
/// maximum value.
/// </param>
/// <param name="provider">An object that supplies culture-specific formatting information.</param>
/// <returns>
/// A <see cref="string" /> that represents this instance.
/// </returns>
public string ToString(string format, string formatRange, IFormatProvider?provider = null) =>
ToString(Minimum?.CompareTo(Maximum) == 0 ? format : formatRange, provider);
