| private static IsZero ( double value ) : bool | ||
| value | double | |
| return | bool | |
private void ValidateFloat(JsonSchemaModel schema)
{
if (schema == null)
{
return;
}
if (!this.TestType(schema, JsonSchemaType.Float))
{
return;
}
this.ValidateInEnumAndNotDisallowed(schema);
double num = Convert.ToDouble(this._reader.Value, CultureInfo.InvariantCulture);
if (schema.Maximum != null)
{
if (num > schema.Maximum)
{
this.RaiseError("Float {0} exceeds maximum value of {1}.".FormatWith(CultureInfo.InvariantCulture, new object[]
{
JsonConvert.ToString(num),
schema.Maximum
}), schema);
}
if (schema.ExclusiveMaximum && num == schema.Maximum)
{
this.RaiseError("Float {0} equals maximum value of {1} and exclusive maximum is true.".FormatWith(CultureInfo.InvariantCulture, new object[]
{
JsonConvert.ToString(num),
schema.Maximum
}), schema);
}
}
if (schema.Minimum != null)
{
if (num < schema.Minimum)
{
this.RaiseError("Float {0} is less than minimum value of {1}.".FormatWith(CultureInfo.InvariantCulture, new object[]
{
JsonConvert.ToString(num),
schema.Minimum
}), schema);
}
if (schema.ExclusiveMinimum && num == schema.Minimum)
{
this.RaiseError("Float {0} equals minimum value of {1} and exclusive minimum is true.".FormatWith(CultureInfo.InvariantCulture, new object[]
{
JsonConvert.ToString(num),
schema.Minimum
}), schema);
}
}
if (schema.DivisibleBy != null && !JsonValidatingReader.IsZero(num % schema.DivisibleBy.Value))
{
this.RaiseError("Float {0} is not evenly divisible by {1}.".FormatWith(CultureInfo.InvariantCulture, new object[]
{
JsonConvert.ToString(num),
schema.DivisibleBy
}), schema);
}
}
// Token: 0x06000D8F RID: 3471 RVA: 0x00054F70 File Offset: 0x00053170
private void ValidateInteger(JsonSchemaModel schema)
{
if (schema == null)
{
return;
}
if (!this.TestType(schema, JsonSchemaType.Integer))
{
return;
}
this.ValidateNotDisallowed(schema);
object value = this._reader.Value;
if (schema.Maximum != null)
{
if (JValue.Compare(JTokenType.Integer, value, schema.Maximum) > 0)
{
this.RaiseError("Integer {0} exceeds maximum value of {1}.".FormatWith(CultureInfo.InvariantCulture, value, schema.Maximum), schema);
}
if (schema.ExclusiveMaximum && JValue.Compare(JTokenType.Integer, value, schema.Maximum) == 0)
{
this.RaiseError("Integer {0} equals maximum value of {1} and exclusive maximum is true.".FormatWith(CultureInfo.InvariantCulture, value, schema.Maximum), schema);
}
}
if (schema.Minimum != null)
{
if (JValue.Compare(JTokenType.Integer, value, schema.Minimum) < 0)
{
this.RaiseError("Integer {0} is less than minimum value of {1}.".FormatWith(CultureInfo.InvariantCulture, value, schema.Minimum), schema);
}
if (schema.ExclusiveMinimum && JValue.Compare(JTokenType.Integer, value, schema.Minimum) == 0)
{
this.RaiseError("Integer {0} equals minimum value of {1} and exclusive minimum is true.".FormatWith(CultureInfo.InvariantCulture, value, schema.Minimum), schema);
}
}
if (schema.DivisibleBy != null)
{
bool flag;
if (value is System.Numerics.BigInteger)
{
System.Numerics.BigInteger bigInteger = (System.Numerics.BigInteger)value;
if (!Math.Abs(schema.DivisibleBy.Value - Math.Truncate(schema.DivisibleBy.Value)).Equals(0.0))
{
flag = (bigInteger != 0L);
}
else
{
flag = (bigInteger % new System.Numerics.BigInteger(schema.DivisibleBy.Value) != 0L);
}
}
else
{
flag = !JsonValidatingReader.IsZero((double)Convert.ToInt64(value, CultureInfo.InvariantCulture) % schema.DivisibleBy.GetValueOrDefault());
}
if (flag)
{
this.RaiseError("Integer {0} is not evenly divisible by {1}.".FormatWith(CultureInfo.InvariantCulture, JsonConvert.ToString(value), schema.DivisibleBy), schema);
}
}
}
private void ValidateFloat(JsonSchemaModel schema)
{
if (schema == null)
{
return;
}
if (!this.TestType(schema, JsonSchemaType.Float))
{
return;
}
this.ValidateNotDisallowed(schema);
double num = Convert.ToDouble(this._reader.Value, CultureInfo.InvariantCulture);
if (schema.Maximum.HasValue)
{
double num2 = num;
double?maximum = schema.Maximum;
if (num2 > maximum.GetValueOrDefault() && maximum.HasValue)
{
this.RaiseError("Float {0} exceeds maximum value of {1}.".FormatWith(CultureInfo.InvariantCulture, JsonConvert.ToString(num), schema.Maximum), schema);
}
if (schema.ExclusiveMaximum)
{
double num3 = num;
double?maximum2 = schema.Maximum;
if (num3 == maximum2.GetValueOrDefault() && maximum2.HasValue)
{
this.RaiseError("Float {0} equals maximum value of {1} and exclusive maximum is true.".FormatWith(CultureInfo.InvariantCulture, JsonConvert.ToString(num), schema.Maximum), schema);
}
}
}
if (schema.Minimum.HasValue)
{
double num4 = num;
double?minimum = schema.Minimum;
if (num4 < minimum.GetValueOrDefault() && minimum.HasValue)
{
this.RaiseError("Float {0} is less than minimum value of {1}.".FormatWith(CultureInfo.InvariantCulture, JsonConvert.ToString(num), schema.Minimum), schema);
}
if (schema.ExclusiveMinimum)
{
double num5 = num;
double?minimum2 = schema.Minimum;
if (num5 == minimum2.GetValueOrDefault() && minimum2.HasValue)
{
this.RaiseError("Float {0} equals minimum value of {1} and exclusive minimum is true.".FormatWith(CultureInfo.InvariantCulture, JsonConvert.ToString(num), schema.Minimum), schema);
}
}
}
if (schema.DivisibleBy.HasValue)
{
double value = JsonValidatingReader.FloatingPointRemainder(num, schema.DivisibleBy.Value);
if (!JsonValidatingReader.IsZero(value))
{
this.RaiseError("Float {0} is not evenly divisible by {1}.".FormatWith(CultureInfo.InvariantCulture, JsonConvert.ToString(num), schema.DivisibleBy), schema);
}
}
}
private void ValidateInteger(JsonSchemaModel schema)
{
if (schema == null)
{
return;
}
if (!this.TestType(schema, JsonSchemaType.Integer))
{
return;
}
this.ValidateInEnumAndNotDisallowed(schema);
long num = Convert.ToInt64(this._reader.Value, CultureInfo.InvariantCulture);
if (schema.Maximum.HasValue)
{
double?maximum = schema.Maximum;
if ((!maximum.HasValue ? false : (double)num > maximum.GetValueOrDefault()))
{
this.RaiseError("Integer {0} exceeds maximum value of {1}.".FormatWith(CultureInfo.InvariantCulture, new object[] { num, schema.Maximum }), schema);
}
if (schema.ExclusiveMaximum)
{
double num1 = (double)num;
double?nullable = schema.Maximum;
if ((num1 != nullable.GetValueOrDefault() ? false : nullable.HasValue))
{
this.RaiseError("Integer {0} equals maximum value of {1} and exclusive maximum is true.".FormatWith(CultureInfo.InvariantCulture, new object[] { num, schema.Maximum }), schema);
}
}
}
if (schema.Minimum.HasValue)
{
double?minimum = schema.Minimum;
if ((!minimum.HasValue ? false : (double)num < minimum.GetValueOrDefault()))
{
this.RaiseError("Integer {0} is less than minimum value of {1}.".FormatWith(CultureInfo.InvariantCulture, new object[] { num, schema.Minimum }), schema);
}
if (schema.ExclusiveMinimum)
{
double num2 = (double)num;
double?minimum1 = schema.Minimum;
if ((num2 != minimum1.GetValueOrDefault() ? false : minimum1.HasValue))
{
this.RaiseError("Integer {0} equals minimum value of {1} and exclusive minimum is true.".FormatWith(CultureInfo.InvariantCulture, new object[] { num, schema.Minimum }), schema);
}
}
}
if (schema.DivisibleBy.HasValue && !JsonValidatingReader.IsZero((double)num % schema.DivisibleBy.Value))
{
this.RaiseError("Integer {0} is not evenly divisible by {1}.".FormatWith(CultureInfo.InvariantCulture, new object[] { JsonConvert.ToString(num), schema.DivisibleBy }), schema);
}
}
private void ValidateFloat(JsonSchemaModel schema)
{
if (schema == null || !this.TestType(schema, JsonSchemaType.Float))
{
return;
}
this.ValidateInEnumAndNotDisallowed(schema);
double num1 = Convert.ToDouble(this._reader.Value, (IFormatProvider)CultureInfo.InvariantCulture);
if (schema.Maximum.HasValue)
{
double num2 = num1;
double?maximum1 = schema.Maximum;
if ((num2 <= maximum1.GetValueOrDefault() ? 0 : (maximum1.HasValue ? 1 : 0)) != 0)
{
this.RaiseError(StringUtils.FormatWith("Float {0} exceeds maximum value of {1}.", (IFormatProvider)CultureInfo.InvariantCulture, (object)JsonConvert.ToString(num1), (object)schema.Maximum), schema);
}
if (schema.ExclusiveMaximum)
{
double num3 = num1;
double?maximum2 = schema.Maximum;
if ((num3 != maximum2.GetValueOrDefault() ? 0 : (maximum2.HasValue ? 1 : 0)) != 0)
{
this.RaiseError(StringUtils.FormatWith("Float {0} equals maximum value of {1} and exclusive maximum is true.", (IFormatProvider)CultureInfo.InvariantCulture, (object)JsonConvert.ToString(num1), (object)schema.Maximum), schema);
}
}
}
if (schema.Minimum.HasValue)
{
double num2 = num1;
double?minimum1 = schema.Minimum;
if ((num2 >= minimum1.GetValueOrDefault() ? 0 : (minimum1.HasValue ? 1 : 0)) != 0)
{
this.RaiseError(StringUtils.FormatWith("Float {0} is less than minimum value of {1}.", (IFormatProvider)CultureInfo.InvariantCulture, (object)JsonConvert.ToString(num1), (object)schema.Minimum), schema);
}
if (schema.ExclusiveMinimum)
{
double num3 = num1;
double?minimum2 = schema.Minimum;
if ((num3 != minimum2.GetValueOrDefault() ? 0 : (minimum2.HasValue ? 1 : 0)) != 0)
{
this.RaiseError(StringUtils.FormatWith("Float {0} equals minimum value of {1} and exclusive minimum is true.", (IFormatProvider)CultureInfo.InvariantCulture, (object)JsonConvert.ToString(num1), (object)schema.Minimum), schema);
}
}
}
if (!schema.DivisibleBy.HasValue || JsonValidatingReader.IsZero(num1 % schema.DivisibleBy.Value))
{
return;
}
this.RaiseError(StringUtils.FormatWith("Float {0} is not evenly divisible by {1}.", (IFormatProvider)CultureInfo.InvariantCulture, (object)JsonConvert.ToString(num1), (object)schema.DivisibleBy), schema);
}
private void ValidateInteger(JsonSchemaModel schema)
{
double?divisibleBy;
bool bigInteger;
if (schema == null)
{
return;
}
if (!this.TestType(schema, JsonSchemaType.Integer))
{
return;
}
this.ValidateNotDisallowed(schema);
object value = this._reader.Value;
if (schema.Maximum.HasValue)
{
if (JValue.Compare(JTokenType.Integer, value, schema.Maximum) > 0)
{
this.RaiseError("Integer {0} exceeds maximum value of {1}.".FormatWith(CultureInfo.InvariantCulture, value, schema.Maximum), schema);
}
if (schema.ExclusiveMaximum && JValue.Compare(JTokenType.Integer, value, schema.Maximum) == 0)
{
this.RaiseError("Integer {0} equals maximum value of {1} and exclusive maximum is true.".FormatWith(CultureInfo.InvariantCulture, value, schema.Maximum), schema);
}
}
if (schema.Minimum.HasValue)
{
if (JValue.Compare(JTokenType.Integer, value, schema.Minimum) < 0)
{
this.RaiseError("Integer {0} is less than minimum value of {1}.".FormatWith(CultureInfo.InvariantCulture, value, schema.Minimum), schema);
}
if (schema.ExclusiveMinimum && JValue.Compare(JTokenType.Integer, value, schema.Minimum) == 0)
{
this.RaiseError("Integer {0} equals minimum value of {1} and exclusive minimum is true.".FormatWith(CultureInfo.InvariantCulture, value, schema.Minimum), schema);
}
}
if (schema.DivisibleBy.HasValue)
{
object obj = value;
object obj1 = obj;
if (!(obj is BigInteger))
{
double num = (double)Convert.ToInt64(value, CultureInfo.InvariantCulture);
divisibleBy = schema.DivisibleBy;
bigInteger = !JsonValidatingReader.IsZero(num % divisibleBy.GetValueOrDefault());
}
else
{
BigInteger bigInteger1 = (BigInteger)obj1;
if (Math.Abs(schema.DivisibleBy.Value - Math.Truncate(schema.DivisibleBy.Value)).Equals(0))
{
divisibleBy = schema.DivisibleBy;
bigInteger = (bigInteger1 % new BigInteger(divisibleBy.Value)) != 0L;
}
else
{
bigInteger = bigInteger1 != 0L;
}
}
if (bigInteger)
{
this.RaiseError("Integer {0} is not evenly divisible by {1}.".FormatWith(CultureInfo.InvariantCulture, JsonConvert.ToString(value), schema.DivisibleBy), schema);
}
}
}
private void ValidateFloat(JsonSchemaModel schema)
{
if (schema == null)
{
return;
}
if (!this.TestType(schema, JsonSchemaType.Float))
{
return;
}
this.ValidateInEnumAndNotDisallowed(schema);
double num = Convert.ToDouble(this._reader.Value, CultureInfo.get_InvariantCulture());
if (schema.Maximum.get_HasValue())
{
double?maximum = schema.Maximum;
if (maximum.get_HasValue() && num > maximum.get_Value())
{
this.RaiseError("Float {0} exceeds maximum value of {1}.".FormatWith(CultureInfo.get_InvariantCulture(), new object[]
{
JsonConvert.ToString(num),
schema.Maximum
}), schema);
}
if (schema.ExclusiveMaximum)
{
double arg_B7_0 = num;
double?maximum2 = schema.Maximum;
if (arg_B7_0 == maximum2.GetValueOrDefault() && maximum2.get_HasValue())
{
this.RaiseError("Float {0} equals maximum value of {1} and exclusive maximum is true.".FormatWith(CultureInfo.get_InvariantCulture(), new object[]
{
JsonConvert.ToString(num),
schema.Maximum
}), schema);
}
}
}
if (schema.Minimum.get_HasValue())
{
double?minimum = schema.Minimum;
if (minimum.get_HasValue() && num < minimum.get_Value())
{
this.RaiseError("Float {0} is less than minimum value of {1}.".FormatWith(CultureInfo.get_InvariantCulture(), new object[]
{
JsonConvert.ToString(num),
schema.Minimum
}), schema);
}
if (schema.ExclusiveMinimum)
{
double arg_183_0 = num;
double?minimum2 = schema.Minimum;
if (arg_183_0 == minimum2.GetValueOrDefault() && minimum2.get_HasValue())
{
this.RaiseError("Float {0} equals minimum value of {1} and exclusive minimum is true.".FormatWith(CultureInfo.get_InvariantCulture(), new object[]
{
JsonConvert.ToString(num),
schema.Minimum
}), schema);
}
}
}
if (schema.DivisibleBy.get_HasValue() && !JsonValidatingReader.IsZero(num % schema.DivisibleBy.get_Value()))
{
this.RaiseError("Float {0} is not evenly divisible by {1}.".FormatWith(CultureInfo.get_InvariantCulture(), new object[]
{
JsonConvert.ToString(num),
schema.DivisibleBy
}), schema);
}
}
