Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Set non-JSON-schema-defined is<type> functions to reflect the internal data storage type #1541

Open
wants to merge 5 commits into
base: master
Choose a base branch
from
Open

Set non-JSON-schema-defined is<type> functions to reflect the internal data storage type #1541

Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
bef6762
set non-JSON-schema-defined is<type> functions to reflect the interna…
Jun 15, 2024
3ad2a4a
Merge branch 'master' into master
baylesj Sep 10, 2024
dcd7aea
Merge branch 'master' into master
baylesj Sep 10, 2024
cf8a11e
Merge branch 'master' into master
baylesj Sep 11, 2024
4dea76d
Merge branch 'master' into master
baylesj Sep 12, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
111 changes: 15 additions & 96 deletions src/lib_json/json_value.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1265,123 +1265,42 @@ bool Value::isNull() const { return type() == nullValue; }

bool Value::isBool() const { return type() == booleanValue; }

// This is evaluated with respect to the underlying data storage type
bool Value::isInt() const {
switch (type()) {
case intValue:
#if defined(JSON_HAS_INT64)
return value_.int_ >= minInt && value_.int_ <= maxInt;
#else
return true;
#endif
case uintValue:
return value_.uint_ <= UInt(maxInt);
case realValue:
return value_.real_ >= minInt && value_.real_ <= maxInt &&
IsIntegral(value_.real_);
default:
break;
}
return false;
return type() == intValue;
}

// This is evaluated with respect to the underlying data storage type
bool Value::isUInt() const {
switch (type()) {
case intValue:
#if defined(JSON_HAS_INT64)
return value_.int_ >= 0 && LargestUInt(value_.int_) <= LargestUInt(maxUInt);
#else
return value_.int_ >= 0;
#endif
case uintValue:
#if defined(JSON_HAS_INT64)
return value_.uint_ <= maxUInt;
#else
return true;
#endif
case realValue:
return value_.real_ >= 0 && value_.real_ <= maxUInt &&
IsIntegral(value_.real_);
default:
break;
}
return false;
return type() == uintValue;
}

// This is evaluated with respect to the underlying data storage type
bool Value::isInt64() const {
#if defined(JSON_HAS_INT64)
switch (type()) {
case intValue:
return true;
case uintValue:
return value_.uint_ <= UInt64(maxInt64);
case realValue:
// Note that maxInt64 (= 2^63 - 1) is not exactly representable as a
// double, so double(maxInt64) will be rounded up to 2^63. Therefore we
// require the value to be strictly less than the limit.
// minInt64 is -2^63 which can be represented as a double, but since double
// values in its proximity are also rounded to -2^63, we require the value
// to be strictly greater than the limit to avoid returning 'true' for
// values that are not in the range
return value_.real_ > double(minInt64) && value_.real_ < double(maxInt64) &&
IsIntegral(value_.real_);
default:
break;
}
return type() == intValue;
#endif // JSON_HAS_INT64
return false;
}

// This is evaluated with respect to the underlying data storage type
bool Value::isUInt64() const {
#if defined(JSON_HAS_INT64)
switch (type()) {
case intValue:
return value_.int_ >= 0;
case uintValue:
return true;
case realValue:
// Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
// double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
// require the value to be strictly less than the limit.
return value_.real_ >= 0 && value_.real_ < maxUInt64AsDouble &&
IsIntegral(value_.real_);
default:
break;
}
return type() == uintValue;
#endif // JSON_HAS_INT64
return false;
}

bool Value::isIntegral() const {
switch (type()) {
case intValue:
case uintValue:
return true;
case realValue:
#if defined(JSON_HAS_INT64)
// Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
// double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
// require the value to be strictly less than the limit.
// minInt64 is -2^63 which can be represented as a double, but since double
// values in its proximity are also rounded to -2^63, we require the value
// to be strictly greater than the limit to avoid returning 'true' for
// values that are not in the range
return value_.real_ > double(minInt64) &&
value_.real_ < maxUInt64AsDouble && IsIntegral(value_.real_);
#else
return value_.real_ >= minInt && value_.real_ <= maxUInt &&
IsIntegral(value_.real_);
#endif // JSON_HAS_INT64
default:
break;
}
return false;
}
// This is evaluated with respect to the underlying data storage type
bool Value::isDouble() const { return type() == realValue; }

bool Value::isDouble() const {
return type() == intValue || type() == uintValue || type() == realValue;
// This is evaluated with respect to the definition of a JSON integer
bool Value::isIntegral() const {
return type() == intValue || type() == uintValue || (type() == realValue && IsIntegral(value_.real_));
}

bool Value::isNumeric() const { return isDouble(); }
// This is evaluated with respect to the definition of a JSON number
bool Value::isNumeric() const { return type() == intValue || type() == uintValue || type() == realValue; }

bool Value::isString() const { return type() == stringValue; }

Expand Down
Loading