[#BloombergLP-bdljsn-JsonNumber]
= xref:BloombergLP.adoc[BloombergLP]::xref:BloombergLP/bdljsn.adoc[bdljsn]::JsonNumber
:relfileprefix: ../../
:mrdocs:

This class defines a value‐semantic class that represents a JSON number. Objects of this class have a value determined at construction and does not change except by assignment from or swap with another `JsonNumber` object. The value can be specified by supplying a string that conforms to the {JSON Textual Specification} or from one of the {Supported Types}. The value of a JSON object can be converted to any of those types; however, some of those conversions can be inexact.

== Synopsis

Declared in `<bdljsn_jsonnumber.h>`

[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
class JsonNumber;
----

== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdljsn/JsonNumber/allocator_type.adoc[`allocator_type`] 
| This `typedef` is an alias for `allocator_type`.
|===


== Enums

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdljsn/JsonNumber/_04enum.adoc[`Unnamed enum`] 
| Undocumented symbol.
|===


== Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdljsn/JsonNumber/2constructor-031.adoc[`JsonNumber`]         [.small]#[constructor]#
| Constructors
| xref:BloombergLP/bdljsn/JsonNumber/operator_assign-0ad.adoc[`operator=`] 
| Assignment operators
| xref:BloombergLP/bdljsn/JsonNumber/allocator.adoc[`allocator`]  [.small]#[deprecated]#
| *DEPRECATED*: Use `get_allocator()` instead.
| xref:BloombergLP/bdljsn/JsonNumber/asDecimal64.adoc[`asDecimal64`] 
| Same as the related overload above for `asDecimal64`.
| xref:BloombergLP/bdljsn/JsonNumber/asDecimal64Exact.adoc[`asDecimal64Exact`] 
| Load to the specified `result` the closest floating point representation to this number, even if a non‐zero status is returned. Return 0 if this number can be represented exactly, and return `k_INEXACT` and load `result` with the closest approximation if `value` cannot be represented exactly. If this number is outside the representable range, load `result` with `+INF` or `‐INF` (as appropriate). A number can be represented exactly as a `Decimal64` if, for the significand and exponent, `abs(significand) <= 9,999,999,999,999,999` and `‐398 <= exponent <= 369`.
| xref:BloombergLP/bdljsn/JsonNumber/asDouble.adoc[`asDouble`] 
| Same as the related overload above for `asDouble`.
| xref:BloombergLP/bdljsn/JsonNumber/asFloat.adoc[`asFloat`] 
| Return the closest floating point representation to this number. If this number is outside the representable range, return `+INF` or `‐INF` (as appropriate). Note that values smaller than the smallest representable non‐zero value (a.k.a, `MIN`) are rounded to `MIN` (positive or negative, as appropriate) or 0, whichever is the better approximation.
| xref:BloombergLP/bdljsn/JsonNumber/asInt.adoc[`asInt`] 
| Same as the related overload above for `asInt`.
| xref:BloombergLP/bdljsn/JsonNumber/asInt64.adoc[`asInt64`] 
| Same as the related overload above for `asInt64`.
| xref:BloombergLP/bdljsn/JsonNumber/asLong.adoc[`asLong`] 
| Same as the related overload above for `asLong`.
| xref:BloombergLP/bdljsn/JsonNumber/asLonglong.adoc[`asLonglong`] 
| Same as the related overload above for `asLonglong`.
| xref:BloombergLP/bdljsn/JsonNumber/asShort.adoc[`asShort`] 
| Load into the specified `result` the integer value of this number. Return 0 on success, `k_OVERFLOW` if `value` is larger than can be represented by `result`, `k_UNDERFLOW` if `value` is smaller than can be represented by `result`, and `k_NOT_INTEGRAL` if `value` is not an integral number (i.e., there is a fractional part). For underflow, `result` will be loaded with the minimum representable value, for overflow, `result` will be loaded with the maximum representable value, for non‐integral values `result` will be loaded with the integer part of `value` (truncating the fractional part). If the result is not an integer and also either overflows or underflows, it is treated as an overflow or underflow (respectively). Note that this operation returns an error status value (unlike similar floating point conversions) because typically it is an error if a conversion to an integer results in an in‐exact value.
| xref:BloombergLP/bdljsn/JsonNumber/asUint.adoc[`asUint`] 
| Same as the related overload above for `asUint`.
| xref:BloombergLP/bdljsn/JsonNumber/asUint64.adoc[`asUint64`] 
| Same as the related overload above for `asUint64`.
| xref:BloombergLP/bdljsn/JsonNumber/asUlong.adoc[`asUlong`] 
| Same as the related overload above for `asUlong`.
| xref:BloombergLP/bdljsn/JsonNumber/asUlonglong.adoc[`asUlonglong`] 
| Same as the related overload above for `asUlonglong`.
| xref:BloombergLP/bdljsn/JsonNumber/asUshort.adoc[`asUshort`] 
| Same as the related overload above for `asUshort`.
| xref:BloombergLP/bdljsn/JsonNumber/get_allocator.adoc[`get_allocator`] 
| Return the allocator used by this object to supply memory.
| xref:BloombergLP/bdljsn/JsonNumber/isEqual.adoc[`isEqual`] 
| Return `true` if this number and the specified `other` number represent the same numeric value, and `false` otherwise. This method will return `true` for differing representations of the same number (e.g., `1.0`, "1", "0.1e+1" are all equivalent) _except_ in cases where the exponent cannot be represented by a 64‐bit integer. If the exponent is outside the range of a 64‐bit integer, `true` will be returned if `*this == other`. For example, comparing "1e18446744073709551615" with itself will return `true`, but comparing it to "10e18446744073709551614" will return `false`. Note that this method is more computationally expensive than the equality and inequality operators.
| xref:BloombergLP/bdljsn/JsonNumber/isIntegral.adoc[`isIntegral`] 
| Return `true` if the value of this `JsonNumber` is an (exact) integral value, or `false` otherwise. Note that this function may return `true` even this number cannot be represented in a fundamental integral type.
| xref:BloombergLP/bdljsn/JsonNumber/print.adoc[`print`] 
| Write the value of this object to the specified output `stream` in a human‐readable format, and return a non‐`const` reference to `stream`. Optionally specify an initial indentation `level`, whose absolute value is incremented recursively for nested objects. If `level` is specified, optionally specify `spacesPerLevel`, whose absolute value indicates the number of spaces per indentation level for this and all of its nested objects. If `level` is negative, suppress indentation of the first line. If `spacesPerLevel` is negative, format the entire output on one line, suppressing all but the initial indentation (as governed by `level`). If `stream` is not valid on entry, this operation has no effect. Note that the format is not fully specified, and can change without notice.
| xref:BloombergLP/bdljsn/JsonNumber/swap.adoc[`swap`] 
| Efficiently exchange the value of this object with the value of the specified `other` object. This method provides the no‐throw exception‐safety guarantee. The behavior is undefined unless this object was created with the same allocator as `other`.
| xref:BloombergLP/bdljsn/JsonNumber/value.adoc[`value`] 
| Return the textual representation of this `JsonNumber`.
| xref:BloombergLP/bdljsn/JsonNumber/2conversion-03b.adoc[`operator BloombergLP::bslmf::NestedTraitDeclaration<JsonNumber, IsBitwiseMoveable>`] 
| Declare nested type traits for this type.
| xref:BloombergLP/bdljsn/JsonNumber/2conversion-0e.adoc[`operator bdldfp::Decimal64`] 
| Same as the related overload above for `operator Decimal_Type64`.
| xref:BloombergLP/bdljsn/JsonNumber/2conversion-0f.adoc[`operator double`] 
| Same as the related overload above for `operator double`.
| xref:BloombergLP/bdljsn/JsonNumber/2conversion-03d.adoc[`operator float`] 
| Return the closest floating point representation to this number. If this number is outside the representable range, return `+INF` or `‐INF` (as appropriate). Note that the values returned by these operators match those returned by `asFloat`, `asDouble`, and `asDecimal64`, respectively.
|===


== Static Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdljsn/JsonNumber/isValidNumber.adoc[`isValidNumber`] 
| Return `true` if the specified `text` complies with the grammar of a JSON number, and `false` otherwise. See the {JSON Textual Specification}.
|===


== Friends

[cols="1,4"]
|===
| Name| Description
| `xref:BloombergLP/bdljsn/swap-088.adoc[BloombergLP::bdljsn::swap]`
| Exchange the values of the specified `a` and `b` objects. This function provides the no‐throw exception‐safety guarantee if the two objects were created with the same allocator and the basic guarantee otherwise.
|===

== Non-Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdljsn/operator_not_eq-010.adoc[`operator!=`]
| Same as the related overload above for `operator!=`.
| xref:BloombergLP/bdljsn/operator_not_eq-059.adoc[`operator!=`]
| Return `true` if the specified `lhs` and `rhs` objects do not have the same value, and `false` otherwise. Two `JsonNumber` objects do not have the same value if their `value` attributes are not the same.
| xref:BloombergLP/bdljsn/operator_eq-0a8.adoc[`operator==`]
| Same as the related overload above for `operator==`.
| xref:BloombergLP/bdljsn/operator_eq-0fe.adoc[`operator==`]
| Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise. Two `JsonNumber` objects have the same value if their `value` attributes are the same.
|===


[.small]#Created with https://www.mrdocs.com[MrDocs]#