private bool ValidCore(object value)
{
if (_comparer != null)
{
return _comparer.Equals(_valueToCompare, value);
}
if (Member.MemberType.IsValueType && _typeOfValueToCompare.IsValueType)
{
if (ValueTypeEqualCalculator.Valid(Member.MemberType, value, _typeOfValueToCompare, _valueToCompare))
return true;
}
return Equals(_valueToCompare, value);
}
private bool ValidCore(object value, out string message)
{
message = null;
if (Member.MemberType.IsValueType && _typeOfValueToCompare.IsValueType)
{
if (ValueTypeEqualCalculator.CompareTo(Member.MemberType, value, _typeOfValueToCompare, _valueToCompare) <= 0)
{
return(true);
}
}
else if (value is IComparable c1 && _valueToCompare is IComparable c2)
{
if (c1.CompareTo(c2) <= 0)
{
return(true);
}
}
message = "Neither the given value nor the value being compared can be converted to IComparable.";
return(false);
}
/// <summary>
/// Impl of valid ops.
/// </summary>
/// <param name="value"></param>
/// <param name="valueToCompare"></param>
/// <param name="typeOfValueToCompare"></param>
/// <param name="message"></param>
/// <returns></returns>
protected override bool IsValidImpl(object value, object valueToCompare, Type typeOfValueToCompare, out string message)
{
message = null;
if (VerifiableMember.MemberType.IsValueType && typeOfValueToCompare.IsValueType)
{
if (ValueTypeEqualCalculator.CompareTo(VerifiableMember.MemberType, value, typeOfValueToCompare, valueToCompare) <= 0)
{
return(true);
}
}
else if (value is IComparable c1 && valueToCompare is IComparable c2)
{
if (c1.CompareTo(c2) <= 0)
{
return(true);
}
}
message = "Neither the given value nor the value being compared can be converted to IComparable.";
return(false);
}
public override CorrectVerifyVal ValidValue(object value)
{
var val = new CorrectVerifyVal {
NameOfExecutedRule = NAME
};
if (_returnFalseDirectly)
{
UpdateVal(val, value);
}
else if (value is null)
{
UpdateVal(val, null);
}
else if (value is char c)
{
var fromC = Convert.ToChar(_from);
var toC = Convert.ToChar(_to);
if (_options == RangeOptions.OpenInterval)
{
// Open Interval
if (c <= fromC || c >= toC)
{
UpdateVal(val, c);
}
}
else
{
// Close Interval
if (c < fromC || c > toC)
{
UpdateVal(val, c);
}
}
}
else if (Member.MemberType.IsPrimitive && Member.MemberType.IsValueType)
{
var d = Convert.ToDecimal(value);
var fromD = Convert.ToDecimal(_from);
var toD = Convert.ToDecimal(_to);
if (_options == RangeOptions.OpenInterval)
{
// Open Interval
if (d <= fromD || d >= toD)
{
UpdateVal(val, d);
}
}
else
{
// Close Interval
if (d < fromD || d > toD)
{
UpdateVal(val, d);
}
}
}
else if (value is DateTime || value is DateTimeOffset)
{
var t = ValueTypeEqualCalculator.ToLongTimeTicks(value);
var fromT = ValueTypeEqualCalculator.ToLongTimeTicks(_from);
var toT = ValueTypeEqualCalculator.ToLongTimeTicks(_to);
if (_options == RangeOptions.OpenInterval)
{
// Open Interval
if (t <= fromT || t >= toT)
{
UpdateVal(val, value);
}
}
else
{
// Close Interval
if (t < fromT || t > toT)
{
UpdateVal(val, value);
}
}
}
else if (value is IComparable comparable)
{
if (_options == RangeOptions.OpenInterval)
{
// Open Interval
if (comparable.CompareTo(_from) <= 0 || comparable.CompareTo(_to) >= 0)
{
UpdateVal(val, comparable);
}
}
else
{
// Close Interval
if (comparable.CompareTo(_from) < 0 || comparable.CompareTo(_to) > 0)
{
UpdateVal(val, comparable);
}
}
}
else
{
UpdateVal(val, value, "The given value cannot be compared.");
}
return(val);
}
private bool IsValidImpl(object value, out object currentValue, out string message)
{
message = "";
currentValue = value;
if (_returnFalseDirectly)
{
return(false);
}
else if (value is null)
{
currentValue = null;
return(false);
}
else if (value is char c)
{
var fromC = Convert.ToChar(_from);
var toC = Convert.ToChar(_to);
currentValue = c;
if (_options == RangeOptions.OpenInterval)
{
// Open Interval
if (c <= fromC || c >= toC)
{
return(false);
}
}
else
{
// Close Interval
if (c < fromC || c > toC)
{
return(false);
}
}
}
else if (VerifiableMember.MemberType.IsPrimitive && VerifiableMember.MemberType.IsValueType)
{
var d = Convert.ToDecimal(value);
var fromD = Convert.ToDecimal(_from);
var toD = Convert.ToDecimal(_to);
currentValue = d;
if (_options == RangeOptions.OpenInterval)
{
// Open Interval
if (d <= fromD || d >= toD)
{
return(false);
}
}
else
{
// Close Interval
if (d < fromD || d > toD)
{
return(false);
}
}
}
else if (value is DateTime || value is DateTimeOffset)
{
var t = ValueTypeEqualCalculator.ToLongTimeTicks(value);
var fromT = ValueTypeEqualCalculator.ToLongTimeTicks(_from);
var toT = ValueTypeEqualCalculator.ToLongTimeTicks(_to);
if (_options == RangeOptions.OpenInterval)
{
// Open Interval
if (t <= fromT || t >= toT)
{
return(false);
}
}
else
{
// Close Interval
if (t < fromT || t > toT)
{
return(false);
}
}
}
else if (value is IComparable comparable)
{
currentValue = comparable;
if (_options == RangeOptions.OpenInterval)
{
// Open Interval
if (comparable.CompareTo(_from) <= 0 || comparable.CompareTo(_to) >= 0)
{
return(false);
}
}
else
{
// Close Interval
if (comparable.CompareTo(_from) < 0 || comparable.CompareTo(_to) > 0)
{
return(false);
}
}
}
else
{
message = "The given value cannot be compared.";
return(false);
}
return(true);
}
