//! Builder for the number format.
use core::num;
use crate::error::Error;
use crate::format_flags as flags;
// NOTE: The size of `Option<NonZero>` is guaranteed to be the same.
// https://doc.rust-lang.org/std/num/type.NonZeroUsize.html
/// Type with the exact same size as a `u8`.
#[doc(hidden)]
pub type OptionU8 = Option<num::NonZeroU8>;
/// Add single flag to `SyntaxFormat`.
macro_rules! add_flag {
($format:ident, $bool:expr, $flag:ident) => {
if $bool {
$format |= flags::$flag;
}
};
}
/// Add multiple flags to `SyntaxFormat`.
macro_rules! add_flags {
($format:ident ; $($bool:expr, $flag:ident ;)*) => {{
$(add_flag!($format, $bool, $flag);)*
}};
}
/// Determine if a flag is set in the format.
macro_rules! has_flag {
($format:ident, $flag:ident) => {
$format & flags::$flag != 0
};
}
/// Unwrap `Option` as a const fn.
#[inline(always)]
const fn unwrap_or_zero(option: OptionU8) -> u8 {
match option {
Some(x) => x.get(),
None => 0,
}
}
/// Validating builder for [`NumberFormat`] from the provided specifications.
///
/// Some of the core functionality includes support for:
/// - Digit separators: ignored characters used to make numbers more readable,
/// such as `100,000`.
/// - Non-decimal radixes: writing or parsing numbers written in binary,
/// hexadecimal, or other bases.
/// - Special numbers: disabling support for special floating-point, such as
/// [`NaN`][f64::NAN].
/// - Number components: require signs, significant digits, and more.
///
/// Returns [`NumberFormat`] on calling [`build_strict`] if it was able to
/// compile the format, otherwise, returns [`None`].
///
/// [`NumberFormat`]: crate::NumberFormat
/// [`build_strict`]: Self::build_strict
///
/// # Examples
///
/// To create a format valid for Rust number literals, we can use the builder
/// API:
///
/// ```rust
/// # #[cfg(feature = "format")] {
/// use core::num;
///
/// use lexical_util::{NumberFormat, NumberFormatBuilder};
///
/// // create the format for literal Rust floats
/// const RUST: u128 = NumberFormatBuilder::new()
/// .digit_separator(num::NonZeroU8::new(b'_'))
/// .required_digits(true)
/// .no_positive_mantissa_sign(true)
/// .no_special(true)
/// .internal_digit_separator(true)
/// .trailing_digit_separator(true)
/// .consecutive_digit_separator(true)
/// .build_strict();
///
/// // then, access the formats's properties
/// let format = NumberFormat::<{ RUST }> {};
/// assert!(format.no_positive_mantissa_sign());
/// assert!(format.no_special());
/// assert!(format.internal_digit_separator());
/// assert!(format.trailing_digit_separator());
/// assert!(format.consecutive_digit_separator());
/// assert!(!format.no_exponent_notation());
/// # }
/// ```
///
/// # Fields
///
/// - [`digit_separator`]: Character to separate digits.
/// - [`mantissa_radix`]: Radix for mantissa digits.
/// - [`exponent_base`]: Base for the exponent.
/// - [`exponent_radix`]: Radix for the exponent digits.
/// - [`base_prefix`]: Optional character for the base prefix.
/// - [`base_suffix`]: Optional character for the base suffix.
/// - [`required_integer_digits`]: If digits are required before the decimal
/// point.
/// - [`required_fraction_digits`]: If digits are required after the decimal
/// point.
/// - [`required_exponent_digits`]: If digits are required after the exponent
/// character.
/// - [`required_mantissa_digits`]: If at least 1 significant digit is required.
/// - [`no_positive_mantissa_sign`]: If positive sign before the mantissa is not
/// allowed.
/// - [`required_mantissa_sign`]: If positive sign before the mantissa is
/// required.
/// - [`no_exponent_notation`]: If exponent notation is not allowed.
/// - [`no_positive_exponent_sign`]: If positive sign before the exponent is not
/// allowed.
/// - [`required_exponent_sign`]: If sign before the exponent is required.
/// - [`no_exponent_without_fraction`]: If exponent without fraction is not
/// allowed.
/// - [`no_special`]: If special (non-finite) values are not allowed.
/// - [`case_sensitive_special`]: If special (non-finite) values are
/// case-sensitive.
/// - [`no_integer_leading_zeros`]: If leading zeros before an integer are not
/// allowed.
/// - [`no_float_leading_zeros`]: If leading zeros before a float are not
/// allowed.
/// - [`required_exponent_notation`]: If exponent notation is required.
/// - [`case_sensitive_exponent`]: If exponent characters are case-sensitive.
/// - [`case_sensitive_base_prefix`]: If base prefixes are case-sensitive.
/// - [`case_sensitive_base_suffix`]: If base suffixes are case-sensitive.
/// - [`integer_internal_digit_separator`]: If digit separators are allowed
/// between integer digits.
/// - [`fraction_internal_digit_separator`]: If digit separators are allowed
/// between fraction digits.
/// - [`exponent_internal_digit_separator`]: If digit separators are allowed
/// between exponent digits.
/// - [`integer_leading_digit_separator`]: If a digit separator is allowed
/// before any integer digits.
/// - [`fraction_leading_digit_separator`]: If a digit separator is allowed
/// before any fraction digits.
/// - [`exponent_leading_digit_separator`]: If a digit separator is allowed
/// before any exponent digits.
/// - [`integer_trailing_digit_separator`]: If a digit separator is allowed
/// after any integer digits.
/// - [`fraction_trailing_digit_separator`]: If a digit separator is allowed
/// after any fraction digits.
/// - [`exponent_trailing_digit_separator`]: If a digit separator is allowed
/// after any exponent digits.
/// - [`integer_consecutive_digit_separator`]: If multiple consecutive integer
/// digit separators are allowed.
/// - [`fraction_consecutive_digit_separator`]: If multiple consecutive fraction
/// digit separators are allowed.
/// - [`special_digit_separator`]: If any digit separators are allowed in
/// special (non-finite) values.
///
/// # Write Integer Fields
///
/// No fields are used for writing integers.
///
/// # Parse Integer Fields
///
/// These fields are used for parsing integers:
///
/// - [`digit_separator`]: Character to separate digits.
/// - [`mantissa_radix`]: Radix for mantissa digits.
/// - [`base_prefix`]: Optional character for the base prefix.
/// - [`base_suffix`]: Optional character for the base suffix.
/// - [`no_positive_mantissa_sign`]: If positive sign before the mantissa is not
/// allowed.
/// - [`required_mantissa_sign`]: If positive sign before the mantissa is
/// required.
/// - [`no_integer_leading_zeros`]: If leading zeros before an integer are not
/// allowed.
/// - [`integer_internal_digit_separator`]: If digit separators are allowed
/// between integer digits.
/// - [`integer_leading_digit_separator`]: If a digit separator is allowed
/// before any integer digits.
/// - [`integer_trailing_digit_separator`]: If a digit separator is allowed
/// after any integer digits.
/// - [`integer_consecutive_digit_separator`]: If multiple consecutive integer
/// digit separators are allowed.
///
/// # Write Float Fields
///
/// These fields are used for writing floats:
///
/// - [`mantissa_radix`]: Radix for mantissa digits.
/// - [`exponent_base`]: Base for the exponent.
/// - [`exponent_radix`]: Radix for the exponent digits.
/// - [`no_positive_mantissa_sign`]: If positive sign before the mantissa is not
/// allowed.
/// - [`required_mantissa_sign`]: If positive sign before the mantissa is
/// required.
/// - [`no_exponent_notation`]: If exponent notation is not allowed.
/// - [`no_positive_exponent_sign`]: If positive sign before the exponent is not
/// allowed.
/// - [`required_exponent_sign`]: If sign before the exponent is required.
/// - [`required_exponent_notation`]: If exponent notation is required.
///
/// # Parse Float Fields
///
/// These fields are used for parsing floats:
///
/// - [`digit_separator`]: Character to separate digits.
/// - [`mantissa_radix`]: Radix for mantissa digits.
/// - [`exponent_base`]: Base for the exponent.
/// - [`exponent_radix`]: Radix for the exponent digits.
/// - [`base_prefix`]: Optional character for the base prefix.
/// - [`base_suffix`]: Optional character for the base suffix.
/// - [`required_mantissa_digits`]: If at least 1 significant digit is required.
/// - [`required_integer_digits`]: If digits are required before the decimal
/// point.
/// - [`required_fraction_digits`]: If digits are required after the decimal
/// point.
/// - [`required_exponent_digits`]: If digits are required after the exponent
/// character.
/// - [`no_positive_mantissa_sign`]: If positive sign before the mantissa is not
/// allowed.
/// - [`required_mantissa_sign`]: If positive sign before the mantissa is
/// required.
/// - [`no_exponent_notation`]: If exponent notation is not allowed.
/// - [`no_positive_exponent_sign`]: If positive sign before the exponent is not
/// allowed.
/// - [`required_exponent_sign`]: If sign before the exponent is required.
/// - [`no_exponent_without_fraction`]: If exponent without fraction is not
/// allowed.
/// - [`no_special`]: If special (non-finite) values are not allowed.
/// - [`case_sensitive_special`]: If special (non-finite) values are
/// case-sensitive.
/// - [`no_integer_leading_zeros`]: If leading zeros before an integer are not
/// allowed.
/// - [`no_float_leading_zeros`]: If leading zeros before a float are not
/// allowed.
/// - [`required_exponent_notation`]: If exponent notation is required.
/// - [`case_sensitive_exponent`]: If exponent characters are case-sensitive.
/// - [`case_sensitive_base_prefix`]: If base prefixes are case-sensitive.
/// - [`case_sensitive_base_suffix`]: If base suffixes are case-sensitive.
/// - [`integer_internal_digit_separator`]: If digit separators are allowed
/// between integer digits.
/// - [`fraction_internal_digit_separator`]: If digit separators are allowed
/// between fraction digits.
/// - [`exponent_internal_digit_separator`]: If digit separators are allowed
/// between exponent digits.
/// - [`integer_leading_digit_separator`]: If a digit separator is allowed
/// before any integer digits.
/// - [`fraction_leading_digit_separator`]: If a digit separator is allowed
/// before any fraction digits.
/// - [`exponent_leading_digit_separator`]: If a digit separator is allowed
/// before any exponent digits.
/// - [`integer_trailing_digit_separator`]: If a digit separator is allowed
/// after any integer digits.
/// - [`fraction_trailing_digit_separator`]: If a digit separator is allowed
/// after any fraction digits.
/// - [`exponent_trailing_digit_separator`]: If a digit separator is allowed
/// after any exponent digits.
/// - [`integer_consecutive_digit_separator`]: If multiple consecutive integer
/// digit separators are allowed.
/// - [`fraction_consecutive_digit_separator`]: If multiple consecutive fraction
/// digit separators are allowed.
/// - [`special_digit_separator`]: If any digit separators are allowed in
/// special (non-finite) values.
#[cfg_attr(
feature = "power-of-two",
doc = "\n
[`exponent_base`]: Self::exponent_base
[`exponent_radix`]: Self::exponent_radix
[`mantissa_radix`]: Self::mantissa_radix
"
)]
#[cfg_attr(
not(feature = "power-of-two"),
doc = "\n
[`exponent_base`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L602\n
[`exponent_radix`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L610\n
[`mantissa_radix`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L594\n
"
)]
#[cfg_attr(
feature = "format",
doc = "\n
[`digit_separator`]: Self::digit_separator\n
[`required_integer_digits`]: Self::required_integer_digits\n
[`required_fraction_digits`]: Self::required_fraction_digits\n
[`required_exponent_digits`]: Self::required_exponent_digits\n
[`required_mantissa_digits`]: Self::required_mantissa_digits\n
[`no_positive_mantissa_sign`]: Self::no_positive_mantissa_sign\n
[`required_mantissa_sign`]: Self::required_mantissa_sign\n
[`no_exponent_notation`]: Self::no_exponent_notation\n
[`no_positive_exponent_sign`]: Self::no_positive_exponent_sign\n
[`required_exponent_sign`]: Self::required_exponent_sign\n
[`no_exponent_without_fraction`]: Self::no_exponent_without_fraction\n
[`no_special`]: Self::no_special\n
[`case_sensitive_special`]: Self::case_sensitive_special\n
[`no_integer_leading_zeros`]: Self::no_integer_leading_zeros\n
[`no_float_leading_zeros`]: Self::no_float_leading_zeros\n
[`required_exponent_notation`]: Self::required_exponent_notation\n
[`case_sensitive_exponent`]: Self::case_sensitive_exponent\n
[`integer_internal_digit_separator`]: Self::integer_internal_digit_separator\n
[`fraction_internal_digit_separator`]: Self::fraction_internal_digit_separator\n
[`exponent_internal_digit_separator`]: Self::exponent_internal_digit_separator\n
[`integer_leading_digit_separator`]: Self::integer_leading_digit_separator\n
[`fraction_leading_digit_separator`]: Self::fraction_leading_digit_separator\n
[`exponent_leading_digit_separator`]: Self::exponent_leading_digit_separator\n
[`integer_trailing_digit_separator`]: Self::integer_trailing_digit_separator\n
[`fraction_trailing_digit_separator`]: Self::fraction_trailing_digit_separator\n
[`exponent_trailing_digit_separator`]: Self::exponent_trailing_digit_separator\n
[`integer_consecutive_digit_separator`]: Self::integer_consecutive_digit_separator\n
[`fraction_consecutive_digit_separator`]: Self::fraction_consecutive_digit_separator\n
[`special_digit_separator`]: Self::special_digit_separator\n
"
)]
#[cfg_attr(
not(feature = "format"),
doc = "\n
[`digit_separator`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L579\n
[`required_integer_digits`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L634\n
[`required_fraction_digits`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L642\n
[`required_exponent_digits`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L650\n
[`required_mantissa_digits`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L658\n
[`no_positive_mantissa_sign`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L677\n
[`required_mantissa_sign`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L685\n
[`no_exponent_notation`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L693\n
[`no_positive_exponent_sign`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L701\n
[`required_exponent_sign`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L709\n
[`no_exponent_without_fraction`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L717\n
[`no_special`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L725\n
[`case_sensitive_special`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L733\n
[`no_integer_leading_zeros`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L741\n
[`no_float_leading_zeros`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L749\n
[`required_exponent_notation`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L757\n
[`case_sensitive_exponent`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L765\n
[`integer_internal_digit_separator`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L793\n
[`fraction_internal_digit_separator`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L805\n
[`exponent_internal_digit_separator`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L817\n
[`integer_leading_digit_separator`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L842\n
[`fraction_leading_digit_separator`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L853\n
[`exponent_leading_digit_separator`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L864\n
[`integer_trailing_digit_separator`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L888\n
[`fraction_trailing_digit_separator`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L899\n
[`exponent_trailing_digit_separator`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L910\n
[`integer_consecutive_digit_separator`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L931\n
[`fraction_consecutive_digit_separator`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L939\n
[`special_digit_separator`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L965\n
"
)]
#[cfg_attr(
all(feature = "format", feature = "power-of-two"),
doc = "\n
[`base_prefix`]: Self::base_prefix
[`base_suffix`]: Self::base_suffix
[`case_sensitive_base_prefix`]: Self::case_sensitive_base_prefix
[`case_sensitive_base_suffix`]: Self::case_sensitive_base_suffix
"
)]
#[cfg_attr(
not(all(feature = "format", feature = "power-of-two")),
doc = "\n
[`base_prefix`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L618\n
[`base_suffix`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L626\n
[`case_sensitive_base_prefix`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L773\n
[`case_sensitive_base_suffix`]: https://github.com/Alexhuszagh/rust-lexical/blob/c6c5052/lexical-util/src/format_builder.rs#L781\n
"
)]
pub struct NumberFormatBuilder {
digit_separator: OptionU8,
base_prefix: OptionU8,
base_suffix: OptionU8,
mantissa_radix: u8,
exponent_base: OptionU8,
exponent_radix: OptionU8,
required_integer_digits: bool,
required_fraction_digits: bool,
required_exponent_digits: bool,
required_mantissa_digits: bool,
no_positive_mantissa_sign: bool,
required_mantissa_sign: bool,
no_exponent_notation: bool,
no_positive_exponent_sign: bool,
required_exponent_sign: bool,
no_exponent_without_fraction: bool,
no_special: bool,
case_sensitive_special: bool,
no_integer_leading_zeros: bool,
no_float_leading_zeros: bool,
required_exponent_notation: bool,
case_sensitive_exponent: bool,
case_sensitive_base_prefix: bool,
case_sensitive_base_suffix: bool,
integer_internal_digit_separator: bool,
fraction_internal_digit_separator: bool,
exponent_internal_digit_separator: bool,
integer_leading_digit_separator: bool,
fraction_leading_digit_separator: bool,
exponent_leading_digit_separator: bool,
integer_trailing_digit_separator: bool,
fraction_trailing_digit_separator: bool,
exponent_trailing_digit_separator: bool,
integer_consecutive_digit_separator: bool,
fraction_consecutive_digit_separator: bool,
exponent_consecutive_digit_separator: bool,
special_digit_separator: bool,
}
impl NumberFormatBuilder {
// CONSTRUCTORS
/// Create new [`NumberFormatBuilder`] with default arguments.
///
/// The default values are:
/// - [`digit_separator`][Self::get_digit_separator] - `None`
/// - [`base_prefix`][Self::get_base_prefix] - `None`
/// - [`base_suffix`][Self::get_base_suffix] - `None`
/// - [`mantissa_radix`][Self::get_mantissa_radix] - `10`
/// - [`exponent_base`][Self::get_exponent_base] - `None`
/// - [`exponent_radix`][Self::get_exponent_radix] - `None`
/// - [`required_integer_digits`][Self::get_required_integer_digits] -
/// `false`
/// - [`required_fraction_digits`][Self::get_required_fraction_digits] -
/// `false`
/// - [`required_exponent_digits`][Self::get_required_exponent_digits] -
/// `true`
/// - [`required_mantissa_digits`][Self::get_required_mantissa_digits] -
/// `true`
/// - [`no_positive_mantissa_sign`][Self::get_no_positive_mantissa_sign] -
/// `false`
/// - [`required_mantissa_sign`][Self::get_required_mantissa_sign] - `false`
/// - [`no_exponent_notation`][Self::get_no_exponent_notation] - `false`
/// - [`no_positive_exponent_sign`][Self::get_no_positive_exponent_sign] -
/// `false`
/// - [`required_exponent_sign`][Self::get_required_exponent_sign] - `false`
/// - [`no_exponent_without_fraction`][Self::get_no_exponent_without_fraction] -
/// `false`
/// - [`no_special`][Self::get_no_special] - `false`
/// - [`case_sensitive_special`][Self::get_case_sensitive_special] - `false`
/// - [`no_integer_leading_zeros`][Self::get_no_integer_leading_zeros] -
/// `false`
/// - [`no_float_leading_zeros`][Self::get_no_float_leading_zeros] - `false`
/// - [`required_exponent_notation`][Self::get_required_exponent_notation] -
/// `false`
/// - [`case_sensitive_exponent`][Self::get_case_sensitive_exponent] -
/// `false`
/// - [`case_sensitive_base_prefix`][Self::get_case_sensitive_base_prefix] -
/// `false`
/// - [`case_sensitive_base_suffix`][Self::get_case_sensitive_base_suffix] -
/// `false`
/// - [`integer_internal_digit_separator`][Self::get_integer_internal_digit_separator] - `false`
/// - [`fraction_internal_digit_separator`][Self::get_fraction_internal_digit_separator] - `false`
/// - [`exponent_internal_digit_separator`][Self::get_exponent_internal_digit_separator] - `false`
/// - [`integer_leading_digit_separator`][Self::get_integer_leading_digit_separator] - `false`
/// - [`fraction_leading_digit_separator`][Self::get_fraction_leading_digit_separator] - `false`
/// - [`exponent_leading_digit_separator`][Self::get_exponent_leading_digit_separator] - `false`
/// - [`integer_trailing_digit_separator`][Self::get_integer_trailing_digit_separator] - `false`
/// - [`fraction_trailing_digit_separator`][Self::get_fraction_trailing_digit_separator] - `false`
/// - [`exponent_trailing_digit_separator`][Self::get_exponent_trailing_digit_separator] - `false`
/// - [`integer_consecutive_digit_separator`][Self::get_integer_consecutive_digit_separator] - `false`
/// - [`fraction_consecutive_digit_separator`][Self::get_fraction_consecutive_digit_separator] - `false`
/// - [`exponent_consecutive_digit_separator`][Self::get_exponent_consecutive_digit_separator] - `false`
/// - [`special_digit_separator`][Self::get_special_digit_separator] -
/// `false`
#[inline(always)]
pub const fn new() -> Self {
Self {
digit_separator: None,
base_prefix: None,
base_suffix: None,
mantissa_radix: 10,
exponent_base: None,
exponent_radix: None,
required_integer_digits: false,
required_fraction_digits: false,
required_exponent_digits: true,
required_mantissa_digits: true,
no_positive_mantissa_sign: false,
required_mantissa_sign: false,
no_exponent_notation: false,
no_positive_exponent_sign: false,
required_exponent_sign: false,
no_exponent_without_fraction: false,
no_special: false,
case_sensitive_special: false,
no_integer_leading_zeros: false,
no_float_leading_zeros: false,
required_exponent_notation: false,
case_sensitive_exponent: false,
case_sensitive_base_prefix: false,
case_sensitive_base_suffix: false,
integer_internal_digit_separator: false,
fraction_internal_digit_separator: false,
exponent_internal_digit_separator: false,
integer_leading_digit_separator: false,
fraction_leading_digit_separator: false,
exponent_leading_digit_separator: false,
integer_trailing_digit_separator: false,
fraction_trailing_digit_separator: false,
exponent_trailing_digit_separator: false,
integer_consecutive_digit_separator: false,
fraction_consecutive_digit_separator: false,
exponent_consecutive_digit_separator: false,
special_digit_separator: false,
}
}
/// Create number format for standard, binary number.
#[cfg(feature = "power-of-two")]
pub const fn binary() -> u128 {
Self::from_radix(2)
}
/// Create number format for standard, octal number.
#[cfg(feature = "power-of-two")]
pub const fn octal() -> u128 {
Self::from_radix(8)
}
/// Create number format for standard, decimal number.
pub const fn decimal() -> u128 {
let mut builder = Self::new();
builder.mantissa_radix = 10;
builder.exponent_base = num::NonZeroU8::new(10);
builder.exponent_radix = num::NonZeroU8::new(10);
builder.build_strict()
}
/// Create number format for standard, hexadecimal number.
#[cfg(feature = "power-of-two")]
pub const fn hexadecimal() -> u128 {
Self::from_radix(16)
}
/// Create number format from radix.
///
/// <div class="warning">
///
/// This function will never fail even if the radix is invalid. It is up to
/// the caller to ensure the format is valid using
/// [`NumberFormat::is_valid`]. Only radixes from `2` to `36` should be
/// used.
///
/// </div>
///
/// [`NumberFormat::is_valid`]: crate::NumberFormat::is_valid
// FIXME: Use `build_strict` when we can have a breaking change.
#[allow(deprecated)]
#[cfg(feature = "power-of-two")]
pub const fn from_radix(radix: u8) -> u128 {
Self::new()
.radix(radix)
.exponent_base(num::NonZeroU8::new(radix))
.exponent_radix(num::NonZeroU8::new(radix))
.build()
}
// GETTERS
// NOTE: This contains a lot of tests for our tables that would spam our
// documentation, so we hide them internally. See `scripts/docs.py` for
// how the tests are generated and run. This assumes the `format` and
// `radix` features are enabled.
/// Get the digit separator for the number format.
///
/// Digit separators are frequently used in number literals to group
/// digits: `1,000,000` is a lot more readable than `1000000`, but
/// the `,` characters should be ignored in the parsing of the number.
///
/// Can only be modified with [`feature`][crate#features] `format`. Defaults
/// to [`None`], or no digit separators allowed.
///
/// # Examples
///
/// Using a digit separator of `_` (note that the validity
/// oh where a digit separator can appear depends on the other digit
/// separator flags).
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1` | ✔️ |
/// | `1_4` | ✔️ |
/// | `+_14` | ✔️ |
/// | `+14e3_5` | ✔️ |
/// | `1_d` | ❌ |
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
#[inline(always)]
pub const fn get_digit_separator(&self) -> OptionU8 {
self.digit_separator
}
/// Get the radix for mantissa digits.
///
/// This is only used for the significant digits, that is, the integral and
/// fractional components. Can only be modified with
/// [`feature`][crate#features] `power-of-two` or `radix`. Defaults
/// to `10`.
///
/// | Radix | String | Number |
/// |:-:|:-:|:-:|
/// | 2 | "10011010010" | 1234 |
/// | 3 | "1200201" | 1234 |
/// | 8 | "2322" | 1234 |
/// | 10 | "1234" | 1234 |
/// | 16 | "4d2" | 1234 |
/// | 31 | "18p" | 1234 |
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
/// - Write Float
/// - Write Integer
#[inline(always)]
pub const fn get_mantissa_radix(&self) -> u8 {
self.mantissa_radix
}
/// Get the radix for the exponent.
///
/// For example, in `1.234e3`, it means `1.234 * 10^3`, and the exponent
/// base here is 10. Some programming languages, like C, support hex floats
/// with an exponent base of 2, for example `0x1.8p3`, or `1.5 * 2^3`.
/// Defaults to `10`. Can only be modified with [`feature`][crate#features]
/// `power-of-two` or `radix`. Defaults to `10`.
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
#[inline(always)]
pub const fn get_exponent_base(&self) -> OptionU8 {
self.exponent_base
}
/// Get the radix for exponent digits.
///
/// This is only used for the exponent digits. We assume the radix for the
/// significant digits ([`get_mantissa_radix`][Self::get_mantissa_radix]) is
/// 10 as is the exponent base. Defaults to `10`. Can only be modified with
/// [`feature`][crate#features] `power-of-two` or `radix`. Defaults to `10`.
///
/// | Radix | String | Number |
/// |:-:|:-:|:-:|
/// | 2 | "1.234^1100" | 1.234e9 |
/// | 3 | "1.234^110" | 1.234e9 |
/// | 8 | "1.234^14" | 1.234e9 |
/// | 10 | "1.234^12" | 1.234e9 |
/// | 16 | "1.234^c" | 1.234e9 |
/// | 31 | "1.234^c" | 1.234e9 |
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
#[inline(always)]
pub const fn get_exponent_radix(&self) -> OptionU8 {
self.exponent_radix
}
/// Get the optional character for the base prefix.
///
/// This character will come after a leading zero, so for example
/// setting the base prefix to `x` means that a leading `0x` will
/// be ignore, if present. Can only be modified with
/// [`feature`][crate#features] `power-of-two` or `radix` along with
/// `format`. Defaults to [`None`], or no base prefix allowed.
///
/// # Examples
///
/// Using a base prefix of `x`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `0x1` | ✔️ |
/// | `x1` | ❌ |
/// | `1` | ✔️ |
/// | `1x` | ❌ |
/// | `1x1` | ❌ |
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
#[inline(always)]
pub const fn get_base_prefix(&self) -> OptionU8 {
self.base_prefix
}
/// Get the optional character for the base suffix.
///
/// This character will at the end of the buffer, so for example
/// setting the base prefix to `x` means that a trailing `x` will
/// be ignored, if present. Can only be modified with
/// [`feature`][crate#features] `power-of-two` or `radix` along with
/// `format`. Defaults to [`None`], or no base suffix allowed.
///
/// # Examples
///
/// Using a base suffix of `x`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1` | ✔️ |
/// | `1x` | ✔️ |
/// | `1d` | ❌ |
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
#[inline(always)]
pub const fn get_base_suffix(&self) -> OptionU8 {
self.base_suffix
}
/// Get if digits are required before the decimal point.
///
/// Can only be modified with [`feature`][crate#features] `format`. Defaults
/// to [`false`].
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1` | ✔️ |
/// | `0.1` | ✔️ |
/// | `1` | ✔️ |
/// | `.1` | ❌ |
///
/// # Used For
///
/// - Parse Float
#[inline(always)]
pub const fn get_required_integer_digits(&self) -> bool {
self.required_integer_digits
}
/// Get if digits are required after the decimal point, if the decimal point
/// is present.
///
/// Can only be modified with [`feature`][crate#features] `format`. Defaults
/// to [`false`].
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1` | ✔️ |
/// | `1` | ✔️ |
/// | `1.` | ❌ |
///
/// # Used For
///
/// - Parse Float
#[inline(always)]
pub const fn get_required_fraction_digits(&self) -> bool {
self.required_fraction_digits
}
/// Get if digits are required after the exponent character, if the exponent
/// is present.
///
/// Can only be modified with [`feature`][crate#features] `format`. Defaults
/// to [`true`].
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1e+3` | ✔️ |
/// | `1.1e3` | ✔️ |
/// | `1.1e+` | ❌ |
/// | `1.1e` | ❌ |
///
/// # Used For
///
/// - Parse Float
#[inline(always)]
pub const fn get_required_exponent_digits(&self) -> bool {
self.required_exponent_digits
}
/// Get if at least 1 significant digit is required.
///
/// If not required, then values like `.` (`0`) are valid, but empty strings
/// are still invalid. Can only be modified with [`feature`][crate#features]
/// `format`. Defaults to [`true`].
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1` | ✔️ |
/// | `.` | ✔️ |
/// | `e10` | ✔️ |
/// | `.e10` | ✔️ |
/// | | ❌ |
///
/// # Used For
///
/// - Parse Float
#[inline(always)]
pub const fn get_required_mantissa_digits(&self) -> bool {
self.required_mantissa_digits
}
/// Get if a positive sign before the mantissa is not allowed.
///
/// Can only be modified with [`feature`][crate#features] `format`. Defaults
/// to `false`.
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1` | ✔️ |
/// | `-1.1` | ✔️ |
/// | `+1.1` | ❌ |
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
/// - Write Float
#[inline(always)]
pub const fn get_no_positive_mantissa_sign(&self) -> bool {
self.no_positive_mantissa_sign
}
/// Get if a sign symbol before the mantissa is required.
///
/// Can only be modified with [`feature`][crate#features] `format`. Defaults
/// to `false`.
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1` | ❌ |
/// | `-1.1` | ✔️ |
/// | `+1.1` | ✔️ |
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
/// - Write Float
#[inline(always)]
pub const fn get_required_mantissa_sign(&self) -> bool {
self.required_mantissa_sign
}
/// Get if exponent notation is not allowed.
///
/// Can only be modified with [`feature`][crate#features] `format`. Defaults
/// to `false`.
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1` | ✔️ |
/// | `1.1` | ✔️ |
/// | `1.1e` | ❌ |
/// | `1.1e5` | ❌ |
///
/// # Used For
///
/// - Parse Float
/// - Write Float
#[inline(always)]
pub const fn get_no_exponent_notation(&self) -> bool {
self.no_exponent_notation
}
/// Get if a positive sign before the exponent is not allowed.
///
/// Can only be modified with [`feature`][crate#features] `format`. Defaults
/// to `false`.
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1e3` | ✔️ |
/// | `1.1e-3` | ✔️ |
/// | `1.1e+3` | ❌ |
///
/// # Used For
///
/// - Parse Float
/// - Write Float
#[inline(always)]
pub const fn get_no_positive_exponent_sign(&self) -> bool {
self.no_positive_exponent_sign
}
/// Get if a sign symbol before the exponent is required.
///
/// Can only be modified with [`feature`][crate#features] `format`. Defaults
/// to `false`.
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1e3` | ❌ |
/// | `1.1e-3` | ✔️ |
/// | `1.1e+3` | ✔️ |
///
/// # Used For
///
/// - Parse Float
/// - Write Float
#[inline(always)]
pub const fn get_required_exponent_sign(&self) -> bool {
self.required_exponent_sign
}
/// Get if an exponent without fraction is not allowed.
///
/// Can only be modified with [`feature`][crate#features] `format`. Defaults
/// to `false`.
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1e3` | ❌ |
/// | `1.e3` | ❌ |
/// | `1.1e` | ✔️ |
/// | `.1e3` | ✔️ |
///
/// # Used For
///
/// - Parse Float
#[inline(always)]
pub const fn get_no_exponent_without_fraction(&self) -> bool {
self.no_exponent_without_fraction
}
/// Get if special (non-finite) values are not allowed.
///
/// Can only be modified with [`feature`][crate#features] `format`. Defaults
/// to `false`.
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `NaN` | ❌ |
/// | `inf` | ❌ |
/// | `-Infinity` | ❌ |
/// | `1.1e` | ✔️ |
///
/// # Used For
///
/// - Parse Float
#[inline(always)]
pub const fn get_no_special(&self) -> bool {
self.no_special
}
/// Get if special (non-finite) values are case-sensitive.
///
/// If set to [`true`], then `NaN` and `nan` are treated as the same value
/// ([Not a Number][f64::NAN]). Can only be modified with
/// [`feature`][crate#features] `format`. Defaults to [`false`].
///
/// # Used For
///
/// - Parse Float
#[inline(always)]
pub const fn get_case_sensitive_special(&self) -> bool {
self.case_sensitive_special
}
/// Get if leading zeros before an integer are not allowed.
///
/// Can only be modified with [`feature`][crate#features] `format`. Defaults
/// to [`false`].
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `01` | ❌ |
/// | `0` | ✔️ |
/// | `10` | ✔️ |
///
/// # Used For
///
/// - Parse Integer
#[inline(always)]
pub const fn get_no_integer_leading_zeros(&self) -> bool {
self.no_integer_leading_zeros
}
/// Get if leading zeros before a float are not allowed.
///
/// This is before the significant digits of the float, that is, if there is
/// 1 or more digits in the integral component and the leading digit is 0,
/// Can only be modified with [`feature`][crate#features] `format`. Defaults
/// to [`false`].
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `01` | ❌ |
/// | `01.0` | ❌ |
/// | `0` | ✔️ |
/// | `10` | ✔️ |
/// | `0.1` | ✔️ |
///
/// # Used For
///
/// - Parse Float
#[inline(always)]
pub const fn get_no_float_leading_zeros(&self) -> bool {
self.no_float_leading_zeros
}
/// Get if exponent notation is required.
///
/// Can only be modified with [`feature`][crate#features] `format`. Defaults
/// to [`false`].
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1` | ❌ |
/// | `1.0` | ❌ |
/// | `1e3` | ✔️ |
/// | `1.1e3` | ✔️ |
///
/// # Used For
///
/// - Parse Float
/// - Write Float
#[inline(always)]
pub const fn get_required_exponent_notation(&self) -> bool {
self.required_exponent_notation
}
/// Get if exponent characters are case-sensitive.
///
/// If set to [`true`], then the exponent character `e` would be considered
/// the different from `E`. Can only be modified with
/// [`feature`][crate#features] `format`. Defaults to [`false`].
///
/// # Used For
///
/// - Parse Float
#[inline(always)]
pub const fn get_case_sensitive_exponent(&self) -> bool {
self.case_sensitive_exponent
}
/// Get if base prefixes are case-sensitive.
///
/// If set to [`true`], then the base prefix `x` would be considered the
/// different from `X`. Can only be modified with
/// [`feature`][crate#features] `power-of-two` or `radix` along with
/// `format`. Defaults to [`false`].
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
#[inline(always)]
pub const fn get_case_sensitive_base_prefix(&self) -> bool {
self.case_sensitive_base_prefix
}
/// Get if base suffixes are case-sensitive.
///
/// If set to [`true`], then the base suffix `x` would be considered the
/// different from `X`. Can only be modified with
/// [`feature`][crate#features] `power-of-two` or `radix` along with
/// `format`. Defaults to [`false`].
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
#[inline(always)]
pub const fn get_case_sensitive_base_suffix(&self) -> bool {
self.case_sensitive_base_suffix
}
/// Get if digit separators are allowed between integer digits.
///
/// This will not consider an input of only the digit separator
/// to be a valid separator: the digit separator must be surrounded by
/// digits. Can only be modified with [`feature`][crate#features] `format`.
/// Defaults to [`false`].
///
/// # Examples
///
/// Using a digit separator of `_`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1` | ✔️ |
/// | `_` | ❌ |
/// | `1_1` | ✔️ |
/// | `1_` | ❌ |
/// | `_1` | ❌ |
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
#[inline(always)]
pub const fn get_integer_internal_digit_separator(&self) -> bool {
self.integer_internal_digit_separator
}
/// Get if digit separators are allowed between fraction digits.
///
/// This will not consider an input of only the digit separator
/// to be a valid separator: the digit separator must be surrounded by
/// digits. Can only be modified with [`feature`][crate#features] `format`.
/// Defaults to [`false`].
///
/// # Examples
///
/// Using a digit separator of `_`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1` | ✔️ |
/// | `1._` | ❌ |
/// | `1.1_1` | ✔️ |
/// | `1.1_` | ❌ |
/// | `1._1` | ❌ |
///
/// # Used For
///
/// - Parse Float
#[inline(always)]
pub const fn get_fraction_internal_digit_separator(&self) -> bool {
self.fraction_internal_digit_separator
}
/// Get if digit separators are allowed between exponent digits.
///
/// This will not consider an input of only the digit separator
/// to be a valid separator: the digit separator must be surrounded by
/// digits. Can only be modified with [`feature`][crate#features] `format`.
/// Defaults to [`false`].
///
/// # Examples
///
/// Using a digit separator of `_`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1e1` | ✔️ |
/// | `1.1e_` | ❌ |
/// | `1.1e1_1` | ✔️ |
/// | `1.1e1_` | ❌ |
/// | `1.1e_1` | ❌ |
///
/// # Used For
///
/// - Parse Float
#[inline(always)]
pub const fn get_exponent_internal_digit_separator(&self) -> bool {
self.exponent_internal_digit_separator
}
/// Get if a digit separator is allowed before any integer digits.
///
/// This will consider an input of only the digit separator
/// to be a identical to empty input. Can only be modified with
/// [`feature`][crate#features] `format`. Defaults to [`false`].
///
/// # Examples
///
/// Using a digit separator of `_`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1` | ✔️ |
/// | `_` | ❌ |
/// | `1_1` | ❌ |
/// | `1_` | ❌ |
/// | `_1` | ✔️ |
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
#[inline(always)]
pub const fn get_integer_leading_digit_separator(&self) -> bool {
self.integer_leading_digit_separator
}
/// Get if a digit separator is allowed before any fraction digits.
///
/// This will consider an input of only the digit separator
/// to be a identical to empty input. Can only be modified with
/// [`feature`][crate#features] `format`. Defaults to [`false`].
///
/// # Examples
///
/// Using a digit separator of `_`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1` | ✔️ |
/// | `1._` | ❌ |
/// | `1.1_1` | ❌ |
/// | `1.1_` | ❌ |
/// | `1._1` | ✔️ |
///
/// # Used For
///
/// - Parse Float
#[inline(always)]
pub const fn get_fraction_leading_digit_separator(&self) -> bool {
self.fraction_leading_digit_separator
}
/// Get if a digit separator is allowed before any exponent digits.
///
/// This will consider an input of only the digit separator
/// to be a identical to empty input. Can only be modified with
/// [`feature`][crate#features] `format`. Defaults to [`false`].
///
/// # Examples
///
/// Using a digit separator of `_`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1e1` | ✔️ |
/// | `1.1e_` | ❌ |
/// | `1.1e1_1` | ❌ |
/// | `1.1e1_` | ❌ |
/// | `1.1e_1` | ✔️ |
///
/// # Used For
///
/// - Parse Float
#[inline(always)]
pub const fn get_exponent_leading_digit_separator(&self) -> bool {
self.exponent_leading_digit_separator
}
/// Get if a digit separator is allowed after any integer digits.
///
/// This will consider an input of only the digit separator
/// to be a identical to empty input. Can only be modified with
/// [`feature`][crate#features] `format`. Defaults to [`false`].
///
/// # Examples
///
/// Using a digit separator of `_`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1` | ✔️ |
/// | `_` | ❌ |
/// | `1_1` | ❌ |
/// | `1_` | ✔️ |
/// | `_1` | ❌ |
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
#[inline(always)]
pub const fn get_integer_trailing_digit_separator(&self) -> bool {
self.integer_trailing_digit_separator
}
/// Get if a digit separator is allowed after any fraction digits.
///
/// This will consider an input of only the digit separator
/// to be a identical to empty input. Can only be modified with
/// [`feature`][crate#features] `format`. Defaults to [`false`]. # Examples
///
/// Using a digit separator of `_`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1` | ✔️ |
/// | `1._` | ❌ |
/// | `1.1_1` | ❌ |
/// | `1.1_` | ✔️ |
/// | `1._1` | ❌ |
///
/// # Used For
///
/// - Parse Float
#[inline(always)]
pub const fn get_fraction_trailing_digit_separator(&self) -> bool {
self.fraction_trailing_digit_separator
}
/// Get if a digit separator is allowed after any exponent digits.
///
/// This will consider an input of only the digit separator
/// to be a identical to empty input. Can only be modified with
/// [`feature`][crate#features] `format`. Defaults to [`false`].
///
/// # Examples
///
/// Using a digit separator of `_`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1e1` | ✔️ |
/// | `1.1e_` | ❌ |
/// | `1.1e1_1` | ❌ |
/// | `1.1e1_` | ✔️ |
/// | `1.1e_1` | ❌ |
///
/// # Used For
///
/// - Parse Float
#[inline(always)]
pub const fn get_exponent_trailing_digit_separator(&self) -> bool {
self.exponent_trailing_digit_separator
}
/// Get if multiple consecutive integer digit separators are allowed.
///
/// That is, using `_` as a digit separator `__` would be allowed where any
/// digit separators (leading, trailing, internal) are allowed in the
/// integer. Can only be modified with [`feature`][crate#features] `format`.
/// Defaults to [`false`].
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
#[inline(always)]
pub const fn get_integer_consecutive_digit_separator(&self) -> bool {
self.integer_consecutive_digit_separator
}
/// Get if multiple consecutive fraction digit separators are allowed.
///
/// That is, using `_` as a digit separator `__` would be allowed where any
/// digit separators (leading, trailing, internal) are allowed in the
/// fraction. Can only be modified with [`feature`][crate#features]
/// `format`. Defaults to [`false`].
///
/// # Used For
///
/// - Parse Float
#[inline(always)]
pub const fn get_fraction_consecutive_digit_separator(&self) -> bool {
self.fraction_consecutive_digit_separator
}
/// Get if multiple consecutive exponent digit separators are allowed.
///
/// That is, using `_` as a digit separator `__` would be allowed where any
/// digit separators (leading, trailing, internal) are allowed in the
/// exponent. Can only be modified with [`feature`][crate#features]
/// `format`. Defaults to [`false`].
///
/// # Used For
///
/// - Parse Float
#[inline(always)]
pub const fn get_exponent_consecutive_digit_separator(&self) -> bool {
self.exponent_consecutive_digit_separator
}
/// Get if any digit separators are allowed in special (non-finite) values.
///
/// This enables leading, trailing, internal, and consecutive digit
/// separators for any special floats: for example, `N__a_N_` is considered
/// the same as `NaN`. Can only be modified with [`feature`][crate#features]
/// `format`. Defaults to [`false`].
///
/// # Used For
///
/// - Parse Float
#[inline(always)]
pub const fn get_special_digit_separator(&self) -> bool {
self.special_digit_separator
}
// SETTERS
/// Set the digit separator for the number format.
///
/// Digit separators are frequently used in number literals to group
/// digits: `1,000,000` is a lot more readable than `1000000`, but
/// the `,` characters should be ignored in the parsing of the number.
///
/// Defaults to [`None`], or no digit separators allowed.
///
/// # Examples
///
/// Using a digit separator of `_` (note that the validity
/// oh where a digit separator can appear depends on the other digit
/// separator flags).
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1` | ✔️ |
/// | `1_4` | ✔️ |
/// | `+_14` | ✔️ |
/// | `+14e3_5` | ✔️ |
/// | `1_d` | ❌ |
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .digit_separator(num::NonZeroU8::new(b'_'))
/// .leading_digit_separator(true)
/// .internal_digit_separator(true)
/// .trailing_digit_separator(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1", &PF_OPTS), Ok(1.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1_4", &PF_OPTS), Ok(14.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"+_14", &PF_OPTS), Ok(14.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"+14e3_5", &PF_OPTS), Ok(14e35));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1_d", &PF_OPTS), Err(Error::InvalidDigit(2)));
///
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1_4", &PI_OPTS), Ok(14));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"+_14", &PI_OPTS), Ok(14));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1_d", &PI_OPTS), Err(Error::InvalidDigit(2)));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn digit_separator(mut self, character: OptionU8) -> Self {
self.digit_separator = character;
self
}
/// Alias for [`mantissa radix`][Self::mantissa_radix].
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
/// - Write Float
/// - Write Integer
#[inline(always)]
#[cfg(feature = "power-of-two")]
pub const fn radix(self, radix: u8) -> Self {
self.mantissa_radix(radix)
}
/// Set the radix for mantissa digits.
///
/// This is only used for the significant digits, that is, the integral and
/// fractional components. Defaults to `10`.
///
/// | Radix | String | Number |
/// |:-:|:-:|:-:|
/// | 2 | "10011010010" | 1234 |
/// | 3 | "1200201" | 1234 |
/// | 8 | "2322" | 1234 |
/// | 10 | "1234" | 1234 |
/// | 16 | "4d2" | 1234 |
/// | 31 | "18p" | 1234 |
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
/// - Write Float
/// - Write Integer
///
/// <!-- TEST
/// ```rust
/// const BASE2: u128 = NumberFormatBuilder::from_radix(2);
/// const BASE3: u128 = NumberFormatBuilder::from_radix(3);
/// const BASE8: u128 = NumberFormatBuilder::from_radix(8);
/// const BASE10: u128 = NumberFormatBuilder::from_radix(10);
/// const BASE16: u128 = NumberFormatBuilder::from_radix(16);
/// const BASE31: u128 = NumberFormatBuilder::from_radix(31);
/// const PI_RDX: ParseIntegerOptions = ParseIntegerOptions::from_radix(16);
/// const PF_RDX: ParseFloatOptions = ParseFloatOptions::from_radix(16);
/// const WI_RDX: WriteIntegerOptions = WriteIntegerOptions::from_radix(16);
/// const WF_RDX: WriteFloatOptions = WriteFloatOptions::from_radix(16);
///
/// assert_eq!(parse_with_options::<f64, BASE2>(b"10011010010", &PF_RDX), Ok(1234.0));
/// assert_eq!(parse_with_options::<f64, BASE3>(b"1200201", &PF_RDX), Ok(1234.0));
/// assert_eq!(parse_with_options::<f64, BASE8>(b"2322", &PF_RDX), Ok(1234.0));
/// assert_eq!(parse_with_options::<f64, BASE10>(b"1234", &PF_RDX), Ok(1234.0));
/// assert_eq!(parse_with_options::<f64, BASE16>(b"4d2", &PF_RDX), Ok(1234.0));
/// assert_eq!(parse_with_options::<f64, BASE31>(b"18p", &PF_RDX), Ok(1234.0));
///
/// assert_eq!(parse_with_options::<i64, BASE2>(b"10011010010", &PI_RDX), Ok(1234));
/// assert_eq!(parse_with_options::<i64, BASE3>(b"1200201", &PI_RDX), Ok(1234));
/// assert_eq!(parse_with_options::<i64, BASE8>(b"2322", &PI_RDX), Ok(1234));
/// assert_eq!(parse_with_options::<i64, BASE10>(b"1234", &PI_RDX), Ok(1234));
/// assert_eq!(parse_with_options::<i64, BASE16>(b"4d2", &PI_RDX), Ok(1234));
/// assert_eq!(parse_with_options::<i64, BASE31>(b"18p", &PI_RDX), Ok(1234));
///
/// let mut buffer = [0u8; BUFFER_SIZE];
/// assert_eq!(write_with_options::<f64, BASE2>(1234.0, &mut buffer, &WF_RDX), b"1.001101001^1010");
/// assert_eq!(write_with_options::<f64, BASE3>(1234.0, &mut buffer, &WF_RDX), b"1200201.0");
/// assert_eq!(write_with_options::<f64, BASE8>(1234.0, &mut buffer, &WF_RDX), b"2.322^3");
/// assert_eq!(write_with_options::<f64, BASE10>(1234.0, &mut buffer, &WF_RDX), b"1234.0");
/// assert_eq!(write_with_options::<f64, BASE16>(1234.0, &mut buffer, &WF_RDX), b"4.D2^2");
/// assert_eq!(write_with_options::<f64, BASE31>(1234.0, &mut buffer, &WF_RDX), b"18P.0");
///
/// assert_eq!(write_with_options::<i64, BASE2>(1234, &mut buffer, &WI_RDX), b"10011010010");
/// assert_eq!(write_with_options::<i64, BASE3>(1234, &mut buffer, &WI_RDX), b"1200201");
/// assert_eq!(write_with_options::<i64, BASE8>(1234, &mut buffer, &WI_RDX), b"2322");
/// assert_eq!(write_with_options::<i64, BASE10>(1234, &mut buffer, &WI_RDX), b"1234");
/// assert_eq!(write_with_options::<i64, BASE16>(1234, &mut buffer, &WI_RDX), b"4D2");
/// assert_eq!(write_with_options::<i64, BASE31>(1234, &mut buffer, &WI_RDX), b"18P");
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "power-of-two")]
pub const fn mantissa_radix(mut self, radix: u8) -> Self {
self.mantissa_radix = radix;
self
}
/// Set the radix for the exponent.
///
/// For example, in `1.234e3`, it means `1.234 * 10^3`, and the exponent
/// base here is 10. Some programming languages, like C, support hex floats
/// with an exponent base of 2, for example `0x1.8p3`, or `1.5 * 2^3`.
/// Defaults to `10`.
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
#[inline(always)]
#[cfg(feature = "power-of-two")]
pub const fn exponent_base(mut self, base: OptionU8) -> Self {
self.exponent_base = base;
self
}
/// Set the radix for exponent digits.
///
/// This is only used for the exponent digits. We assume the radix for the
/// significant digits ([`mantissa_radix`][Self::mantissa_radix]) is 10 as
/// is the exponent base. Defaults to `10`.
///
/// | Radix | String | Number |
/// |:-:|:-:|:-:|
/// | 2 | "1.234^1100" | 1.234e9 |
/// | 3 | "1.234^110" | 1.234e9 |
/// | 8 | "1.234^14" | 1.234e9 |
/// | 10 | "1.234^12" | 1.234e9 |
/// | 16 | "1.234^c" | 1.234e9 |
/// | 31 | "1.234^c" | 1.234e9 |
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
///
/// <!-- TEST
/// ```rust
/// macro_rules! exp_radix {
/// ($exp:literal) => {
/// NumberFormatBuilder::new()
/// .mantissa_radix(10)
/// .exponent_base(num::NonZeroU8::new(10))
/// .exponent_radix(num::NonZeroU8::new($exp))
/// .build_strict()
/// };
/// }
/// const BASE2: u128 = exp_radix!(2);
/// const BASE3: u128 = exp_radix!(3);
/// const BASE8: u128 = exp_radix!(8);
/// const BASE10: u128 = exp_radix!(10);
/// const BASE16: u128 = exp_radix!(16);
/// const BASE31: u128 = exp_radix!(31);
/// const PF_RDX: ParseFloatOptions = ParseFloatOptions::from_radix(16);
/// const WF_RDX: WriteFloatOptions = WriteFloatOptions::from_radix(16);
///
/// assert_eq!(parse_with_options::<f64, BASE2>(b"1.234^1100", &PF_RDX), Ok(1234e9));
/// assert_eq!(parse_with_options::<f64, BASE3>(b"1.234^110", &PF_RDX), Ok(1234e9));
/// assert_eq!(parse_with_options::<f64, BASE8>(b"1.234^14", &PF_RDX), Ok(1234e9));
/// assert_eq!(parse_with_options::<f64, BASE10>(b"1.234^12", &PF_RDX), Ok(1234e9));
/// assert_eq!(parse_with_options::<f64, BASE16>(b"1.234^c", &PF_RDX), Ok(1234e9));
/// assert_eq!(parse_with_options::<f64, BASE31>(b"1.234^c", &PF_RDX), Ok(1234e9));
///
/// let mut buffer = [0u8; BUFFER_SIZE];
/// assert_eq!(write_with_options::<f64, BASE2>(1234e9, &mut buffer, &WF_RDX), b"1.234^1100");
/// assert_eq!(write_with_options::<f64, BASE3>(1234e9, &mut buffer, &WF_RDX), b"1.234^110");
/// assert_eq!(write_with_options::<f64, BASE8>(1234e9, &mut buffer, &WF_RDX), b"1.234^14");
/// assert_eq!(write_with_options::<f64, BASE10>(1234e9, &mut buffer, &WF_RDX), b"1.234^12");
/// assert_eq!(write_with_options::<f64, BASE16>(1234e9, &mut buffer, &WF_RDX), b"1.234^C");
/// assert_eq!(write_with_options::<f64, BASE31>(1234e9, &mut buffer, &WF_RDX), b"1.234^C");
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "power-of-two")]
pub const fn exponent_radix(mut self, radix: OptionU8) -> Self {
self.exponent_radix = radix;
self
}
/// Set the optional character for the base prefix.
///
/// This character will come after a leading zero, so for example
/// setting the base prefix to `x` means that a leading `0x` will
/// be ignore, if present. Defaults to [`None`], or no base prefix
/// allowed.
///
/// # Examples
///
/// Using a base prefix of `x`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `0x1` | ✔️ |
/// | `x1` | ❌ |
/// | `1` | ✔️ |
/// | `1x` | ❌ |
/// | `1x1` | ❌ |
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .base_prefix(num::NonZeroU8::new(b'x'))
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"0x1", &PF_OPTS), Ok(1.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"x1", &PF_OPTS), Err(Error::InvalidDigit(0)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1", &PF_OPTS), Ok(1.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1x", &PF_OPTS), Err(Error::InvalidDigit(1)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1x1", &PF_OPTS), Err(Error::InvalidDigit(1)));
///
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"0x1", &PI_OPTS), Ok(1));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"x1", &PI_OPTS), Err(Error::InvalidDigit(0)));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1", &PI_OPTS), Ok(1));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1x", &PI_OPTS), Err(Error::InvalidDigit(1)));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1x1", &PI_OPTS), Err(Error::InvalidDigit(1)));
/// ```
/// -->
#[inline(always)]
#[cfg(all(feature = "power-of-two", feature = "format"))]
pub const fn base_prefix(mut self, base_prefix: OptionU8) -> Self {
self.base_prefix = base_prefix;
self
}
/// Set the optional character for the base suffix.
///
/// This character will at the end of the buffer, so for example
/// setting the base prefix to `x` means that a trailing `x` will
/// be ignored, if present. Defaults to [`None`], or no base suffix
/// allowed.
///
/// # Examples
///
/// Using a base suffix of `x`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1` | ✔️ |
/// | `1x` | ✔️ |
/// | `1d` | ❌ |
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .base_suffix(num::NonZeroU8::new(b'x'))
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"0x1", &PF_OPTS), Err(Error::InvalidDigit(2)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"x1", &PF_OPTS), Err(Error::InvalidDigit(0)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1", &PF_OPTS), Ok(1.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1x", &PF_OPTS), Ok(1.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1x1", &PF_OPTS), Err(Error::InvalidDigit(2)));
///
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"0x1", &PI_OPTS), Err(Error::InvalidDigit(2)));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"x1", &PI_OPTS), Err(Error::InvalidDigit(0)));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1", &PI_OPTS), Ok(1));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1x", &PI_OPTS), Ok(1));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1x1", &PI_OPTS), Err(Error::InvalidDigit(2)));
/// ```
/// -->
#[inline(always)]
#[cfg(all(feature = "power-of-two", feature = "format"))]
pub const fn base_suffix(mut self, base_suffix: OptionU8) -> Self {
self.base_suffix = base_suffix;
self
}
/// Set if digits are required before the decimal point.
///
/// Defaults to [`false`].
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1` | ✔️ |
/// | `0.1` | ✔️ |
/// | `1` | ✔️ |
/// | `.1` | ❌ |
/// | `1.` | ❌ |
/// | | ❌ |
///
/// # Used For
///
/// - Parse Float
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .required_integer_digits(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1", &PF_OPTS), Ok(1.1));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"0.1", &PF_OPTS), Ok(0.1));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1", &PF_OPTS), Ok(1.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.", &PF_OPTS), Ok(1.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b".1", &PF_OPTS), Err(Error::EmptyInteger(0)));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn required_integer_digits(mut self, flag: bool) -> Self {
self.required_integer_digits = flag;
self
}
/// Set if digits are required after the decimal point, if the decimal point
/// is present.
///
/// Defaults to [`false`].
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1` | ✔️ |
/// | `0.1` | ✔️ |
/// | `1` | ✔️ |
/// | `.1` | ✔️ |
/// | `1.` | ❌ |
/// | | ❌ |
///
/// # Used For
///
/// - Parse Float
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .required_fraction_digits(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1", &PF_OPTS), Ok(1.1));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"0.1", &PF_OPTS), Ok(0.1));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1", &PF_OPTS), Ok(1.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.", &PF_OPTS), Err(Error::EmptyFraction(2)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b".1", &PF_OPTS), Ok(0.1));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn required_fraction_digits(mut self, flag: bool) -> Self {
self.required_fraction_digits = flag;
self
}
/// Set if digits are required after the exponent character, if the exponent
/// is present.
///
/// Defaults to [`true`].
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1e+3` | ✔️ |
/// | `1.1e3` | ✔️ |
/// | `1.1e+` | ❌ |
/// | `1.1e` | ❌ |
///
/// # Used For
///
/// - Parse Float
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .required_fraction_digits(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e+3", &PF_OPTS), Ok(1.1e3));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e3", &PF_OPTS), Ok(1.1e3));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e+", &PF_OPTS), Err(Error::EmptyExponent(5)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e", &PF_OPTS), Err(Error::EmptyExponent(4)));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn required_exponent_digits(mut self, flag: bool) -> Self {
self.required_exponent_digits = flag;
self
}
/// Set if at least 1 significant digit is required.
///
/// If not required, then values like `.` (`0`) are valid, but empty strings
/// are still invalid. Defaults to [`true`].
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1` | ✔️ |
/// | `.` | ✔️ |
/// | `e10` | ❌ |
/// | `.e10` | ❌ |
/// | | ❌ |
///
/// # Used For
///
/// - Parse Float
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .required_mantissa_digits(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1", &PF_OPTS), Ok(1.1));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b".", &PF_OPTS), Err(Error::EmptyMantissa(1)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"e10", &PF_OPTS), Err(Error::EmptyMantissa(0)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b".e10", &PF_OPTS), Err(Error::EmptyMantissa(1)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"", &PF_OPTS), Err(Error::Empty(0)));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn required_mantissa_digits(mut self, flag: bool) -> Self {
self.required_mantissa_digits = flag;
self
}
/// Set if digits are required for all float components.
///
/// Note that digits are **always** required for integers. Defaults
/// to requiring digits only for the mantissa and exponent.
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1` | ✔️ |
/// | `1.1e3` | ✔️ |
/// | `1.1e` | ✔️ |
/// | `0.1` | ✔️ |
/// | `.1` | ❌ |
/// | `1.` | ❌ |
/// | `e10` | ❌ |
/// | `.1e10` | ❌ |
/// | | ❌ |
///
/// # Used For
///
/// - Parse Float
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .required_digits(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1", &PF_OPTS), Ok(1.1));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e3", &PF_OPTS), Ok(1.1e3));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e", &PF_OPTS), Err(Error::EmptyExponent(4)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"0.1", &PF_OPTS), Ok(0.1));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b".", &PF_OPTS), Err(Error::EmptyInteger(0)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"e10", &PF_OPTS), Err(Error::EmptyInteger(0)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b".e10", &PF_OPTS), Err(Error::EmptyInteger(0)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"", &PF_OPTS), Err(Error::Empty(0)));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn required_digits(mut self, flag: bool) -> Self {
self = self.required_integer_digits(flag);
self = self.required_fraction_digits(flag);
self = self.required_exponent_digits(flag);
self = self.required_mantissa_digits(flag);
self
}
/// Set if a positive sign before the mantissa is not allowed.
///
/// Defaults to `false`.
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1` | ✔️ |
/// | `-1.1` | ✔️ |
/// | `+1.1` | ❌ |
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
/// - Write Float
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .no_positive_mantissa_sign(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1", &PF_OPTS), Ok(1.1));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"-1.1", &PF_OPTS), Ok(-1.1));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"+1.1", &PF_OPTS), Err(Error::InvalidPositiveSign(0)));
///
/// let mut buffer = [0u8; BUFFER_SIZE];
/// assert_eq!(write_with_options::<f64, FORMAT>(1.1, &mut buffer, &WF_OPTS), b"1.1");
/// assert_eq!(write_with_options::<f64, FORMAT>(-1.1, &mut buffer, &WF_OPTS), b"-1.1");
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn no_positive_mantissa_sign(mut self, flag: bool) -> Self {
self.no_positive_mantissa_sign = flag;
self
}
/// Set if a sign symbol before the mantissa is required.
///
/// Defaults to `false`.
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1` | ❌ |
/// | `-1.1` | ✔️ |
/// | `+1.1` | ✔️ |
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
/// - Write Float
/// - Write Integer
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .required_mantissa_sign(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1", &PF_OPTS), Err(Error::MissingSign(0)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"+1.1", &PF_OPTS), Ok(1.1));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"-1.1", &PF_OPTS), Ok(-1.1));
///
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1", &PI_OPTS), Err(Error::MissingSign(0)));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"+1", &PI_OPTS), Ok(1));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"-1", &PI_OPTS), Ok(-1));
///
/// let mut buffer = [0u8; BUFFER_SIZE];
/// assert_eq!(write_with_options::<f64, FORMAT>(-1.0, &mut buffer, &WF_OPTS), b"-1.0");
/// assert_eq!(write_with_options::<f64, FORMAT>(1.0, &mut buffer, &WF_OPTS), b"+1.0");
///
/// assert_eq!(write_with_options::<i64, FORMAT>(-1, &mut buffer, &WI_OPTS), b"-1");
/// assert_eq!(write_with_options::<i64, FORMAT>(1, &mut buffer, &WI_OPTS), b"+1");
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn required_mantissa_sign(mut self, flag: bool) -> Self {
self.required_mantissa_sign = flag;
self
}
/// Set if exponent notation is not allowed.
///
/// Defaults to `false`.
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1` | ✔️ |
/// | `1.1` | ✔️ |
/// | `1.1e` | ❌ |
/// | `1.1e5` | ❌ |
///
/// # Used For
///
/// - Parse Float
/// - Write Float
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .no_exponent_notation(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1", &PF_OPTS), Ok(1.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1", &PF_OPTS), Ok(1.1));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e", &PF_OPTS), Err(Error::InvalidExponent(3)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e5", &PF_OPTS), Err(Error::InvalidExponent(3)));
///
/// const SIZE: usize = WF_OPTS.buffer_size_const::<f64, FORMAT>();
/// let mut buffer = [0u8; SIZE];
/// assert_eq!(write(1.0e10, &mut buffer), b"1.0e10");
/// assert_eq!(write_with_options::<f64, FORMAT>(1.0, &mut buffer, &WF_OPTS), b"1.0");
/// assert_eq!(write_with_options::<f64, FORMAT>(1.1, &mut buffer, &WF_OPTS), b"1.1");
/// assert_eq!(write_with_options::<f64, FORMAT>(1.0e10, &mut buffer, &WF_OPTS), b"10000000000.0");
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn no_exponent_notation(mut self, flag: bool) -> Self {
self.no_exponent_notation = flag;
self
}
/// Set if a positive sign before the exponent is not allowed.
///
/// Defaults to `false`.
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1e3` | ✔️ |
/// | `1.1e-3` | ✔️ |
/// | `1.1e+3` | ❌ |
///
/// # Used For
///
/// - Parse Float
/// - Write Float
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .no_positive_exponent_sign(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e15", &PF_OPTS), Ok(1.1e15));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e+15", &PF_OPTS), Err(Error::InvalidPositiveExponentSign(4)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e-15", &PF_OPTS), Ok(1.1e-15));
///
/// let mut buffer = [0u8; BUFFER_SIZE];
/// assert_eq!(write_with_options::<f64, FORMAT>(1.1e15, &mut buffer, &WF_OPTS), b"1.1e15");
/// assert_eq!(write_with_options::<f64, FORMAT>(1.1e-15, &mut buffer, &WF_OPTS), b"1.1e-15");
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn no_positive_exponent_sign(mut self, flag: bool) -> Self {
self.no_positive_exponent_sign = flag;
self
}
/// Set if a sign symbol before the exponent is required.
///
/// Defaults to `false`.
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1e3` | ❌ |
/// | `1.1e-3` | ✔️ |
/// | `1.1e+3` | ✔️ |
///
/// # Used For
///
/// - Parse Float
/// - Write Float
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .required_exponent_sign(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e15", &PF_OPTS), Err(Error::MissingExponentSign(4)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e+15", &PF_OPTS), Ok(1.1e15));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e-15", &PF_OPTS), Ok(1.1e-15));
///
/// let mut buffer = [0u8; BUFFER_SIZE];
/// assert_eq!(write_with_options::<f64, FORMAT>(1.1e15, &mut buffer, &WF_OPTS), b"1.1e+15");
/// assert_eq!(write_with_options::<f64, FORMAT>(1.1e-15, &mut buffer, &WF_OPTS), b"1.1e-15");
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn required_exponent_sign(mut self, flag: bool) -> Self {
self.required_exponent_sign = flag;
self
}
/// Set if an exponent without fraction is not allowed.
///
/// Defaults to `false`.
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1e3` | ❌ |
/// | `1.e3` | ✔️ |
/// | `1.1e` | ✔️ |
/// | `.1e3` | ✔️ |
///
/// # Used For
///
/// - Parse Float
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .no_exponent_without_fraction(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1e3", &PF_OPTS), Err(Error::ExponentWithoutFraction(1)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.e3", &PF_OPTS), Ok(1000.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1", &PF_OPTS), Ok(1.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e3", &PF_OPTS), Ok(1.1e3));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b".1e3", &PF_OPTS), Ok(1.0e2));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn no_exponent_without_fraction(mut self, flag: bool) -> Self {
self.no_exponent_without_fraction = flag;
self
}
/// Set if special (non-finite) values are not allowed.
///
/// Defaults to `false`.
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `NaN` | ❌ |
/// | `inf` | ❌ |
/// | `-Infinity` | ❌ |
/// | `1.1e3` | ✔️ |
///
/// # Used For
///
/// - Parse Float
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .no_special(true)
/// .build_strict();
/// assert_eq!(parse::<f64>(b"NaN").map(|x| x.is_nan()), Ok(true));
/// assert_eq!(parse::<f64>(b"inf"), Ok(f64::INFINITY));
/// assert_eq!(parse::<f64>(b"infinity"), Ok(f64::INFINITY));
/// assert_eq!(parse::<f64>(b"1.1e3"), Ok(1.1e3));
///
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"NaN", &PF_OPTS), Err(Error::InvalidDigit(0)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"inf", &PF_OPTS), Err(Error::InvalidDigit(0)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"infinity", &PF_OPTS), Err(Error::InvalidDigit(0)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e3", &PF_OPTS), Ok(1.1e3));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn no_special(mut self, flag: bool) -> Self {
self.no_special = flag;
self
}
/// Set if special (non-finite) values are case-sensitive.
///
/// If set to [`true`], then `NaN` and `nan` are treated as the same value
/// ([Not a Number][f64::NAN]). Defaults to [`false`].
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `nan` | ❌ |
/// | `NaN` | ✔️ |
/// | `inf` | ✔️ |
/// | `Inf` | ❌ |
///
/// # Used For
///
/// - Parse Float
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .case_sensitive_special(true)
/// .build_strict();
/// assert_eq!(parse::<f64>(b"nan").map(|x| x.is_nan()), Ok(true));
/// assert_eq!(parse::<f64>(b"NaN").map(|x| x.is_nan()), Ok(true));
/// assert_eq!(parse::<f64>(b"inf"), Ok(f64::INFINITY));
/// assert_eq!(parse::<f64>(b"Inf"), Ok(f64::INFINITY));
/// assert_eq!(parse::<f64>(b"1.1e3"), Ok(1.1e3));
///
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"nan", &PF_OPTS), Err(Error::InvalidDigit(0)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"NaN", &PF_OPTS).map(|x| x.is_nan()), Ok(true));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"inf", &PF_OPTS), Ok(f64::INFINITY));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"Inf", &PF_OPTS), Err(Error::InvalidDigit(0)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e3", &PF_OPTS), Ok(1.1e3));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn case_sensitive_special(mut self, flag: bool) -> Self {
self.case_sensitive_special = flag;
self
}
/// Set if leading zeros before an integer are not allowed.
///
/// Defaults to [`false`].
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `01` | ❌ |
/// | `0` | ✔️ |
/// | `10` | ✔️ |
///
/// # Used For
///
/// - Parse Integer
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .no_integer_leading_zeros(true)
/// .build_strict();
/// assert_eq!(parse::<i64>(b"01"), Ok(1));
/// assert_eq!(parse::<i64>(b"+01"), Ok(1));
/// assert_eq!(parse::<i64>(b"0"), Ok(0));
/// assert_eq!(parse::<i64>(b"10"), Ok(10));
///
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"01", &PI_OPTS), Err(Error::InvalidLeadingZeros(0)));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"+01", &PI_OPTS), Err(Error::InvalidLeadingZeros(1)));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"0", &PI_OPTS), Ok(0));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"10", &PI_OPTS), Ok(10));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn no_integer_leading_zeros(mut self, flag: bool) -> Self {
self.no_integer_leading_zeros = flag;
self
}
/// Set if leading zeros before a float are not allowed.
///
/// This is before the significant digits of the float, that is, if there is
/// 1 or more digits in the integral component and the leading digit is 0,
/// Defaults to [`false`].
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `01` | ❌ |
/// | `01.0` | ❌ |
/// | `0` | ✔️ |
/// | `10` | ✔️ |
/// | `0.1` | ✔️ |
///
/// # Used For
///
/// - Parse Float
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .no_float_leading_zeros(true)
/// .build_strict();
/// assert_eq!(parse::<f64>(b"01"), Ok(1.0));
/// assert_eq!(parse::<f64>(b"+01"), Ok(1.0));
/// assert_eq!(parse::<f64>(b"0"), Ok(0.0));
/// assert_eq!(parse::<f64>(b"10"), Ok(10.0));
/// assert_eq!(parse::<f64>(b"0.1"), Ok(0.1));
///
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"01", &PF_OPTS), Err(Error::InvalidLeadingZeros(0)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"+01", &PF_OPTS), Err(Error::InvalidLeadingZeros(1)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"0", &PF_OPTS), Ok(0.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"10", &PF_OPTS), Ok(10.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"0.1", &PF_OPTS), Ok(0.1));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn no_float_leading_zeros(mut self, flag: bool) -> Self {
self.no_float_leading_zeros = flag;
self
}
/// Set if exponent notation is required.
///
/// Defaults to [`false`].
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1` | ❌ |
/// | `1.0` | ❌ |
/// | `1e3` | ✔️ |
/// | `1.1e3` | ✔️ |
///
/// # Used For
///
/// - Parse Float
/// - Write Float
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .required_exponent_notation(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1", &PF_OPTS), Err(Error::MissingExponent(1)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.0", &PF_OPTS), Err(Error::MissingExponent(3)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.0e3", &PF_OPTS), Ok(1.0e3));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e3", &PF_OPTS), Ok(1.1e3));
///
/// const SIZE: usize = WF_OPTS.buffer_size_const::<f64, FORMAT>();
/// let mut buffer = [0u8; SIZE];
/// assert_eq!(write_with_options::<f64, FORMAT>(1.0, &mut buffer, &WF_OPTS), b"1.0e0");
/// assert_eq!(write_with_options::<f64, FORMAT>(1.1, &mut buffer, &WF_OPTS), b"1.1e0");
/// assert_eq!(write_with_options::<f64, FORMAT>(1.0e3, &mut buffer, &WF_OPTS), b"1.0e3");
/// assert_eq!(write_with_options::<f64, FORMAT>(1.1e3, &mut buffer, &WF_OPTS), b"1.1e3");
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn required_exponent_notation(mut self, flag: bool) -> Self {
self.required_exponent_notation = flag;
self
}
/// Set if exponent characters are case-sensitive.
///
/// If set to [`true`], then the exponent character `e` would be considered
/// the different from `E`. Defaults to [`false`].
///
/// # Examples
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1` | ✔️ |
/// | `1.1e3` | ✔️ |
/// | `1.1E3` | ❌ |
///
/// # Used For
///
/// - Parse Float
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .case_sensitive_exponent(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1", &PF_OPTS), Ok(1.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.0e3", &PF_OPTS), Ok(1.0e3));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.0E3", &PF_OPTS), Err(Error::InvalidDigit(3)));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn case_sensitive_exponent(mut self, flag: bool) -> Self {
self.case_sensitive_exponent = flag;
self
}
/// Set if base prefixes are case-sensitive.
///
/// If set to [`true`], then the base prefix `x` would be considered the
/// different from `X`. Defaults to [`false`].
///
/// # Examples
///
/// Using a base prefix of `x`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `0x1` | ✔️ |
/// | `0X1` | ❌ |
/// | `1` | ✔️ |
/// | `1x` | ❌ |
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .base_prefix(num::NonZeroU8::new(b'x'))
/// .case_sensitive_base_prefix(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"0x1", &PF_OPTS), Ok(1.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"0X1", &PF_OPTS), Err(Error::InvalidDigit(1)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1", &PF_OPTS), Ok(1.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1x", &PF_OPTS), Err(Error::InvalidDigit(1)));
///
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"0x1", &PI_OPTS), Ok(1));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"0X1", &PI_OPTS), Err(Error::InvalidDigit(1)));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1", &PI_OPTS), Ok(1));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1x", &PI_OPTS), Err(Error::InvalidDigit(1)));
/// ```
/// -->
#[inline(always)]
#[cfg(all(feature = "power-of-two", feature = "format"))]
pub const fn case_sensitive_base_prefix(mut self, flag: bool) -> Self {
self.case_sensitive_base_prefix = flag;
self
}
/// Set if base suffixes are case-sensitive.
///
/// If set to [`true`], then the base suffix `x` would be considered the
/// different from `X`. Defaults to [`false`].
///
/// # Examples
///
/// Using a base prefix of `x`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1` | ✔️ |
/// | `1x` | ✔️ |
/// | `1X` | ❌ |
/// | `1d` | ❌ |
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .base_suffix(num::NonZeroU8::new(b'x'))
/// .case_sensitive_base_suffix(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"0x1", &PF_OPTS), Err(Error::InvalidDigit(2)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1", &PF_OPTS), Ok(1.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1x", &PF_OPTS), Ok(1.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1X", &PF_OPTS), Err(Error::InvalidDigit(1)));
///
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"0x1", &PI_OPTS), Err(Error::InvalidDigit(2)));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1", &PI_OPTS), Ok(1));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1x", &PI_OPTS), Ok(1));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1X", &PI_OPTS), Err(Error::InvalidDigit(1)));
/// ```
/// -->
#[inline(always)]
#[cfg(all(feature = "power-of-two", feature = "format"))]
pub const fn case_sensitive_base_suffix(mut self, flag: bool) -> Self {
self.case_sensitive_base_suffix = flag;
self
}
/// Set if digit separators are allowed between integer digits.
///
/// This will not consider an input of only the digit separator
/// to be a valid separator: the digit separator must be surrounded by
/// digits. Defaults to [`false`].
///
/// # Examples
///
/// Using a digit separator of `_`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1` | ✔️ |
/// | `_` | ❌ |
/// | `1_1` | ✔️ |
/// | `1_` | ❌ |
/// | `_1` | ❌ |
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .digit_separator(num::NonZeroU8::new(b'_'))
/// .integer_internal_digit_separator(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1", &PF_OPTS), Ok(1.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"_", &PF_OPTS), Err(Error::InvalidDigit(0)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1_1", &PF_OPTS), Ok(11.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1_", &PF_OPTS), Err(Error::InvalidDigit(1)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"_1", &PF_OPTS), Err(Error::InvalidDigit(0)));
///
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1", &PI_OPTS), Ok(1));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"_", &PI_OPTS), Err(Error::InvalidDigit(0)));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1_1", &PI_OPTS), Ok(11));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1_", &PI_OPTS), Err(Error::InvalidDigit(1)));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"_1", &PI_OPTS), Err(Error::InvalidDigit(0)));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn integer_internal_digit_separator(mut self, flag: bool) -> Self {
self.integer_internal_digit_separator = flag;
self
}
/// Set if digit separators are allowed between fraction digits.
///
/// This will not consider an input of only the digit separator
/// to be a valid separator: the digit separator must be surrounded by
/// digits. Defaults to [`false`].
///
/// # Examples
///
/// Using a digit separator of `_`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1` | ✔️ |
/// | `1._` | ❌ |
/// | `1.1_1` | ✔️ |
/// | `1.1_` | ❌ |
/// | `1._1` | ❌ |
///
/// # Used For
///
/// - Parse Float
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .digit_separator(num::NonZeroU8::new(b'_'))
/// .fraction_internal_digit_separator(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1", &PF_OPTS), Ok(1.1));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1._", &PF_OPTS), Err(Error::InvalidDigit(2)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1_1", &PF_OPTS), Ok(1.11));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1_", &PF_OPTS), Err(Error::InvalidDigit(3)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1._1", &PF_OPTS), Err(Error::InvalidDigit(2)));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn fraction_internal_digit_separator(mut self, flag: bool) -> Self {
self.fraction_internal_digit_separator = flag;
self
}
/// Set if digit separators are allowed between exponent digits.
///
/// This will not consider an input of only the digit separator
/// to be a valid separator: the digit separator must be surrounded by
/// digits. Defaults to [`false`].
///
/// # Examples
///
/// Using a digit separator of `_`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1e1` | ✔️ |
/// | `1.1e_` | ❌ |
/// | `1.1e1_1` | ✔️ |
/// | `1.1e1_` | ❌ |
/// | `1.1e_1` | ❌ |
///
/// # Used For
///
/// - Parse Float
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .digit_separator(num::NonZeroU8::new(b'_'))
/// .exponent_internal_digit_separator(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e1", &PF_OPTS), Ok(11.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e_", &PF_OPTS), Err(Error::EmptyExponent(4)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e1_1", &PF_OPTS), Ok(1.1e11));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e1_", &PF_OPTS), Err(Error::InvalidDigit(5)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e_1", &PF_OPTS), Err(Error::EmptyExponent(4)));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn exponent_internal_digit_separator(mut self, flag: bool) -> Self {
self.exponent_internal_digit_separator = flag;
self
}
/// Set all internal digit separator flags.
///
/// This will not consider an input of only the digit separator
/// to be a valid separator: the digit separator must be surrounded by
/// digits. Sets [`integer_internal_digit_separator`],
/// [`fraction_internal_digit_separator`], and
/// [`exponent_internal_digit_separator`].
///
/// [`integer_internal_digit_separator`]: Self::integer_internal_digit_separator
/// [`fraction_internal_digit_separator`]: Self::fraction_internal_digit_separator
/// [`exponent_internal_digit_separator`]: Self::exponent_internal_digit_separator
#[inline(always)]
#[cfg(feature = "format")]
pub const fn internal_digit_separator(mut self, flag: bool) -> Self {
self = self.integer_internal_digit_separator(flag);
self = self.fraction_internal_digit_separator(flag);
self = self.exponent_internal_digit_separator(flag);
self
}
/// Set if a digit separator is allowed before any integer digits.
///
/// This will consider an input of only the digit separator
/// to be a identical to empty input. Defaults to [`false`].
///
/// # Examples
///
/// Using a digit separator of `_`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1` | ✔️ |
/// | `_` | ❌ |
/// | `1_1` | ❌ |
/// | `1_` | ❌ |
/// | `_1` | ✔️ |
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .digit_separator(num::NonZeroU8::new(b'_'))
/// .integer_leading_digit_separator(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1", &PF_OPTS), Ok(1.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"_", &PF_OPTS), Err(Error::Empty(1)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1_1", &PF_OPTS), Err(Error::InvalidDigit(1)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1_", &PF_OPTS), Err(Error::InvalidDigit(1)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"_1", &PF_OPTS), Ok(1.0));
///
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1", &PI_OPTS), Ok(1));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"_", &PI_OPTS), Err(Error::Empty(1)));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1_1", &PI_OPTS), Err(Error::InvalidDigit(1)));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1_", &PI_OPTS), Err(Error::InvalidDigit(1)));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"_1", &PI_OPTS), Ok(1));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn integer_leading_digit_separator(mut self, flag: bool) -> Self {
self.integer_leading_digit_separator = flag;
self
}
/// Set if a digit separator is allowed before any fraction digits.
///
/// This will consider an input of only the digit separator
/// to be a identical to empty input. Defaults to [`false`].
///
/// # Examples
///
/// Using a digit separator of `_`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1` | ✔️ |
/// | `1._` | ✔️ |
/// | `1.1_1` | ❌ |
/// | `1.1_` | ❌ |
/// | `1._1` | ✔️ |
///
/// # Used For
///
/// - Parse Float
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .digit_separator(num::NonZeroU8::new(b'_'))
/// .fraction_leading_digit_separator(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1", &PF_OPTS), Ok(1.1));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1._", &PF_OPTS), Ok(1.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1_1", &PF_OPTS), Err(Error::InvalidDigit(3)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1_", &PF_OPTS), Err(Error::InvalidDigit(3)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1._1", &PF_OPTS), Ok(1.1));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn fraction_leading_digit_separator(mut self, flag: bool) -> Self {
self.fraction_leading_digit_separator = flag;
self
}
/// Set if a digit separator is allowed before any exponent digits.
///
/// This will consider an input of only the digit separator
/// to be a identical to empty input. Defaults to [`false`].
///
/// # Examples
///
/// Using a digit separator of `_`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1e1` | ✔️ |
/// | `1.1e_` | ❌ |
/// | `1.1e1_1` | ❌ |
/// | `1.1e1_` | ❌ |
/// | `1.1e_1` | ✔️ |
///
/// # Used For
///
/// - Parse Float
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .digit_separator(num::NonZeroU8::new(b'_'))
/// .exponent_leading_digit_separator(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e1", &PF_OPTS), Ok(11.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e_", &PF_OPTS), Err(Error::EmptyExponent(5)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e1_1", &PF_OPTS), Err(Error::InvalidDigit(5)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e1_", &PF_OPTS), Err(Error::InvalidDigit(5)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e_1", &PF_OPTS), Ok(11.0));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn exponent_leading_digit_separator(mut self, flag: bool) -> Self {
self.exponent_leading_digit_separator = flag;
self
}
/// Set all leading digit separator flags.
///
/// This will consider an input of only the digit separator
/// to be a identical to empty input. Sets
/// [`integer_leading_digit_separator`],
/// [`fraction_leading_digit_separator`], and
/// [`exponent_leading_digit_separator`].
///
/// [`integer_leading_digit_separator`]: Self::integer_leading_digit_separator
/// [`fraction_leading_digit_separator`]: Self::fraction_leading_digit_separator
/// [`exponent_leading_digit_separator`]: Self::exponent_leading_digit_separator
#[inline(always)]
#[cfg(feature = "format")]
pub const fn leading_digit_separator(mut self, flag: bool) -> Self {
self = self.integer_leading_digit_separator(flag);
self = self.fraction_leading_digit_separator(flag);
self = self.exponent_leading_digit_separator(flag);
self
}
/// Set if a digit separator is allowed after any integer digits.
///
/// This will consider an input of only the digit separator
/// to be a identical to empty input. Defaults to [`false`].
///
/// # Examples
///
/// Using a digit separator of `_`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1` | ✔️ |
/// | `_` | ❌ |
/// | `1_1` | ❌ |
/// | `1_` | ✔️ |
/// | `_1` | ❌ |
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .digit_separator(num::NonZeroU8::new(b'_'))
/// .integer_trailing_digit_separator(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1", &PF_OPTS), Ok(1.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"_", &PF_OPTS), Err(Error::Empty(1)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1_1", &PF_OPTS), Err(Error::InvalidDigit(1)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1_", &PF_OPTS), Ok(1.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"_1", &PF_OPTS), Err(Error::InvalidDigit(0)));
///
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1", &PI_OPTS), Ok(1));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"_", &PI_OPTS), Err(Error::Empty(1)));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1_1", &PI_OPTS), Err(Error::InvalidDigit(1)));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1_", &PI_OPTS), Ok(1));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"_1", &PI_OPTS), Err(Error::InvalidDigit(0)));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn integer_trailing_digit_separator(mut self, flag: bool) -> Self {
self.integer_trailing_digit_separator = flag;
self
}
/// Set if a digit separator is allowed after any fraction digits.
///
/// This will consider an input of only the digit separator
/// to be a identical to empty input. Defaults to [`false`].
/// # Examples
///
/// Using a digit separator of `_`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1` | ✔️ |
/// | `1._` | ✔️ |
/// | `1.1_1` | ❌ |
/// | `1.1_` | ✔️ |
/// | `1._1` | ❌ |
///
/// # Used For
///
/// - Parse Float
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .digit_separator(num::NonZeroU8::new(b'_'))
/// .fraction_trailing_digit_separator(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1", &PF_OPTS), Ok(1.1));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1._", &PF_OPTS), Ok(1.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1_1", &PF_OPTS), Err(Error::InvalidDigit(3)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1._1", &PF_OPTS), Err(Error::InvalidDigit(2)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1_", &PF_OPTS), Ok(1.1));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn fraction_trailing_digit_separator(mut self, flag: bool) -> Self {
self.fraction_trailing_digit_separator = flag;
self
}
/// Set if a digit separator is allowed after any exponent digits.
///
/// This will consider an input of only the digit separator
/// to be a identical to empty input. Defaults to [`false`].
///
/// # Examples
///
/// Using a digit separator of `_`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1e1` | ✔️ |
/// | `1.1e_` | ❌ |
/// | `1.1e1_1` | ❌ |
/// | `1.1e1_` | ✔️ |
/// | `1.1e_1` | ❌ |
///
/// # Used For
///
/// - Parse Float
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .digit_separator(num::NonZeroU8::new(b'_'))
/// .exponent_trailing_digit_separator(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e1", &PF_OPTS), Ok(11.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e_", &PF_OPTS), Err(Error::EmptyExponent(5)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e1_1", &PF_OPTS), Err(Error::InvalidDigit(5)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e1_", &PF_OPTS), Ok(11.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e_1", &PF_OPTS), Err(Error::EmptyExponent(4)));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn exponent_trailing_digit_separator(mut self, flag: bool) -> Self {
self.exponent_trailing_digit_separator = flag;
self
}
/// Set all trailing digit separator flags.
///
/// This will consider an input of only the digit separator
/// to be a identical to empty input. Sets
/// [`integer_trailing_digit_separator`],
/// [`fraction_trailing_digit_separator`], and
/// [`exponent_trailing_digit_separator`].
///
/// [`integer_trailing_digit_separator`]: Self::integer_trailing_digit_separator
/// [`fraction_trailing_digit_separator`]: Self::fraction_trailing_digit_separator
/// [`exponent_trailing_digit_separator`]: Self::exponent_trailing_digit_separator
#[inline(always)]
#[cfg(feature = "format")]
pub const fn trailing_digit_separator(mut self, flag: bool) -> Self {
self = self.integer_trailing_digit_separator(flag);
self = self.fraction_trailing_digit_separator(flag);
self = self.exponent_trailing_digit_separator(flag);
self
}
/// Set if multiple consecutive integer digit separators are allowed.
///
/// That is, using `_` as a digit separator `__` would be allowed where any
/// digit separators (leading, trailing, internal) are allowed in the
/// integer. Defaults to [`false`].
///
/// # Examples
///
/// Using a digit separator of `_` with only internal integer digit
/// separators being valid.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1` | ✔️ |
/// | `_` | ❌ |
/// | `1_1` | ✔️ |
/// | `1__1` | ✔️ |
/// | `1_` | ❌ |
/// | `_1` | ❌ |
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .digit_separator(num::NonZeroU8::new(b'_'))
/// .integer_internal_digit_separator(true)
/// .integer_consecutive_digit_separator(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1", &PF_OPTS), Ok(1.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"_", &PF_OPTS), Err(Error::InvalidDigit(0)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1_1", &PF_OPTS), Ok(11.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1__1", &PF_OPTS), Ok(11.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1_", &PF_OPTS), Err(Error::InvalidDigit(1)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"_1", &PF_OPTS), Err(Error::InvalidDigit(0)));
///
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1", &PI_OPTS), Ok(1));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"_", &PI_OPTS), Err(Error::InvalidDigit(0)));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1_1", &PI_OPTS), Ok(11));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1__1", &PI_OPTS), Ok(11));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"1_", &PI_OPTS), Err(Error::InvalidDigit(1)));
/// assert_eq!(parse_with_options::<i64, FORMAT>(b"_1", &PI_OPTS), Err(Error::InvalidDigit(0)));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn integer_consecutive_digit_separator(mut self, flag: bool) -> Self {
self.integer_consecutive_digit_separator = flag;
self
}
/// Set if multiple consecutive fraction digit separators are allowed.
///
/// That is, using `_` as a digit separator `__` would be allowed where any
/// digit separators (leading, trailing, internal) are allowed in the
/// fraction. Defaults to [`false`].
///
/// # Examples
///
/// Using a digit separator of `_` with only internal fraction digit
/// separators being valid.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1` | ✔️ |
/// | `1._` | ❌ |
/// | `1.1_1` | ✔️ |
/// | `1.1__1` | ✔️ |
/// | `1.1_` | ❌ |
/// | `1._1` | ❌ |
///
/// # Used For
///
/// - Parse Float
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .digit_separator(num::NonZeroU8::new(b'_'))
/// .fraction_internal_digit_separator(true)
/// .fraction_consecutive_digit_separator(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1", &PF_OPTS), Ok(1.1));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1._", &PF_OPTS), Err(Error::InvalidDigit(2)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1_1", &PF_OPTS), Ok(1.11));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1__1", &PF_OPTS), Ok(1.11));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1_", &PF_OPTS), Err(Error::InvalidDigit(3)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1._1", &PF_OPTS), Err(Error::InvalidDigit(2)));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn fraction_consecutive_digit_separator(mut self, flag: bool) -> Self {
self.fraction_consecutive_digit_separator = flag;
self
}
/// Set if multiple consecutive exponent digit separators are allowed.
///
/// That is, using `_` as a digit separator `__` would be allowed where any
/// digit separators (leading, trailing, internal) are allowed in the
/// exponent. Defaults to [`false`].
///
/// # Examples
///
/// Using a digit separator of `_` with only internal exponent digit
/// separators being valid.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `1.1e1` | ✔️ |
/// | `1.1e_` | ❌ |
/// | `1.1e1_1` | ✔️ |
/// | `1.1e1__1` | ✔️ |
/// | `1.1e1_` | ❌ |
/// | `1.1e_1` | ❌ |
///
/// # Used For
///
/// - Parse Float
///
/// <!-- TEST
/// ```rust
/// const FORMAT: u128 = NumberFormatBuilder::new()
/// .digit_separator(num::NonZeroU8::new(b'_'))
/// .exponent_internal_digit_separator(true)
/// .exponent_consecutive_digit_separator(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e1", &PF_OPTS), Ok(11.0));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e_", &PF_OPTS), Err(Error::EmptyExponent(4)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e1_1", &PF_OPTS), Ok(1.1e11));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e1__1", &PF_OPTS), Ok(1.1e11));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e1_", &PF_OPTS), Err(Error::InvalidDigit(5)));
/// assert_eq!(parse_with_options::<f64, FORMAT>(b"1.1e_1", &PF_OPTS), Err(Error::EmptyExponent(4)));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn exponent_consecutive_digit_separator(mut self, flag: bool) -> Self {
self.exponent_consecutive_digit_separator = flag;
self
}
/// Set all consecutive digit separator flags.
///
/// Sets [`integer_consecutive_digit_separator`],
/// [`fraction_consecutive_digit_separator`], and
/// [`exponent_consecutive_digit_separator`].
///
/// [`integer_consecutive_digit_separator`]: Self::integer_consecutive_digit_separator
/// [`fraction_consecutive_digit_separator`]: Self::fraction_consecutive_digit_separator
/// [`exponent_consecutive_digit_separator`]: Self::exponent_consecutive_digit_separator
#[inline(always)]
#[cfg(feature = "format")]
pub const fn consecutive_digit_separator(mut self, flag: bool) -> Self {
self = self.integer_consecutive_digit_separator(flag);
self = self.fraction_consecutive_digit_separator(flag);
self = self.exponent_consecutive_digit_separator(flag);
self
}
/// Set if any digit separators are allowed in special (non-finite) values.
///
/// This enables leading, trailing, internal, and consecutive digit
/// separators for any special floats: for example, `N__a_N_` is considered
/// the same as `NaN`. Defaults to [`false`].
///
/// Using a digit separator of `_`.
///
/// | Input | Valid? |
/// |:-:|:-:|
/// | `nan` | ✔️ |
/// | `na_n` | ✔️ |
/// | `na_n_` | ✔️ |
/// | `na_nx` | ❌ |
///
/// # Used For
///
/// - Parse Float
///
/// <!-- TEST
/// ```rust
/// const FMT: u128 = NumberFormatBuilder::new()
/// .digit_separator(num::NonZeroU8::new(b'_'))
/// .special_digit_separator(true)
/// .build_strict();
/// assert_eq!(parse_with_options::<f64, FMT>(b"nan", &PF_OPTS).map(|x| x.is_nan()), Ok(true));
/// assert_eq!(parse_with_options::<f64, FMT>(b"na_n", &PF_OPTS).map(|x| x.is_nan()), Ok(true));
/// assert_eq!(parse_with_options::<f64, FMT>(b"na_n_", &PF_OPTS).map(|x| x.is_nan()), Ok(true));
/// assert_eq!(parse_with_options::<f64, FMT>(b"na_nx", &PF_OPTS), Err(Error::InvalidDigit(0)));
/// ```
/// -->
#[inline(always)]
#[cfg(feature = "format")]
pub const fn special_digit_separator(mut self, flag: bool) -> Self {
self.special_digit_separator = flag;
self
}
/// Allow digit separators in all locations for all components.
///
/// This enables leading, trailing, internal, and consecutive digit
/// separators for the integer, fraction, and exponent components. Defaults
/// to [`false`].
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
#[inline(always)]
#[cfg(feature = "format")]
pub const fn digit_separator_flags(mut self, flag: bool) -> Self {
self = self.integer_digit_separator_flags(flag);
self = self.fraction_digit_separator_flags(flag);
self = self.exponent_digit_separator_flags(flag);
self = self.special_digit_separator(flag);
self
}
/// Set all integer digit separator flag masks.
///
/// This enables leading, trailing, internal, and consecutive digit
/// separators for the integer component. Defaults to [`false`].
///
/// # Used For
///
/// - Parse Float
/// - Parse Integer
#[inline(always)]
#[cfg(feature = "format")]
pub const fn integer_digit_separator_flags(mut self, flag: bool) -> Self {
self = self.integer_internal_digit_separator(flag);
self = self.integer_leading_digit_separator(flag);
self = self.integer_trailing_digit_separator(flag);
self = self.integer_consecutive_digit_separator(flag);
self
}
/// Set all fraction digit separator flag masks.
///
/// This enables leading, trailing, internal, and consecutive digit
/// separators for the fraction component. Defaults to [`false`].
///
/// # Used For
///
/// - Parse Float
#[inline(always)]
#[cfg(feature = "format")]
pub const fn fraction_digit_separator_flags(mut self, flag: bool) -> Self {
self = self.fraction_internal_digit_separator(flag);
self = self.fraction_leading_digit_separator(flag);
self = self.fraction_trailing_digit_separator(flag);
self = self.fraction_consecutive_digit_separator(flag);
self
}
/// Set all exponent digit separator flag masks.
///
/// This enables leading, trailing, internal, and consecutive digit
/// separators for the exponent component. Defaults to [`false`].
///
/// # Used For
///
/// - Parse Float
#[inline(always)]
#[cfg(feature = "format")]
pub const fn exponent_digit_separator_flags(mut self, flag: bool) -> Self {
self = self.exponent_internal_digit_separator(flag);
self = self.exponent_leading_digit_separator(flag);
self = self.exponent_trailing_digit_separator(flag);
self = self.exponent_consecutive_digit_separator(flag);
self
}
// BUILDER
/// Create 128-bit, packed number format struct from builder options.
///
/// <div class="warning">
///
/// This function will never fail. It is up to the caller to ensure the
/// format is valid using [`NumberFormat::is_valid`].
///
/// </div>
///
/// [`NumberFormat::is_valid`]: crate::NumberFormat::is_valid
#[inline(always)]
pub const fn build_unchecked(&self) -> u128 {
let mut format: u128 = 0;
add_flags!(
format ;
self.required_integer_digits, REQUIRED_INTEGER_DIGITS ;
self.required_fraction_digits, REQUIRED_FRACTION_DIGITS ;
self.required_exponent_digits, REQUIRED_EXPONENT_DIGITS ;
self.required_mantissa_digits, REQUIRED_MANTISSA_DIGITS ;
self.no_positive_mantissa_sign, NO_POSITIVE_MANTISSA_SIGN ;
self.required_mantissa_sign, REQUIRED_MANTISSA_SIGN ;
self.no_exponent_notation, NO_EXPONENT_NOTATION ;
self.no_positive_exponent_sign, NO_POSITIVE_EXPONENT_SIGN ;
self.required_exponent_sign, REQUIRED_EXPONENT_SIGN ;
self.no_exponent_without_fraction, NO_EXPONENT_WITHOUT_FRACTION ;
self.no_special, NO_SPECIAL ;
self.case_sensitive_special, CASE_SENSITIVE_SPECIAL ;
self.no_integer_leading_zeros, NO_INTEGER_LEADING_ZEROS ;
self.no_float_leading_zeros, NO_FLOAT_LEADING_ZEROS ;
self.required_exponent_notation, REQUIRED_EXPONENT_NOTATION ;
self.case_sensitive_exponent, CASE_SENSITIVE_EXPONENT ;
self.case_sensitive_base_prefix, CASE_SENSITIVE_BASE_PREFIX ;
self.case_sensitive_base_suffix, CASE_SENSITIVE_BASE_SUFFIX ;
self.integer_internal_digit_separator, INTEGER_INTERNAL_DIGIT_SEPARATOR ;
self.fraction_internal_digit_separator, FRACTION_INTERNAL_DIGIT_SEPARATOR ;
self.exponent_internal_digit_separator, EXPONENT_INTERNAL_DIGIT_SEPARATOR ;
self.integer_leading_digit_separator, INTEGER_LEADING_DIGIT_SEPARATOR ;
self.fraction_leading_digit_separator, FRACTION_LEADING_DIGIT_SEPARATOR ;
self.exponent_leading_digit_separator, EXPONENT_LEADING_DIGIT_SEPARATOR ;
self.integer_trailing_digit_separator, INTEGER_TRAILING_DIGIT_SEPARATOR ;
self.fraction_trailing_digit_separator, FRACTION_TRAILING_DIGIT_SEPARATOR ;
self.exponent_trailing_digit_separator, EXPONENT_TRAILING_DIGIT_SEPARATOR ;
self.integer_consecutive_digit_separator, INTEGER_CONSECUTIVE_DIGIT_SEPARATOR ;
self.fraction_consecutive_digit_separator, FRACTION_CONSECUTIVE_DIGIT_SEPARATOR ;
self.exponent_consecutive_digit_separator, EXPONENT_CONSECUTIVE_DIGIT_SEPARATOR ;
self.special_digit_separator, SPECIAL_DIGIT_SEPARATOR ;
);
if format & flags::DIGIT_SEPARATOR_FLAG_MASK != 0 {
format |=
(unwrap_or_zero(self.digit_separator) as u128) << flags::DIGIT_SEPARATOR_SHIFT;
}
format |= (unwrap_or_zero(self.base_prefix) as u128) << flags::BASE_PREFIX_SHIFT;
format |= (unwrap_or_zero(self.base_suffix) as u128) << flags::BASE_SUFFIX_SHIFT;
format |= (self.mantissa_radix as u128) << flags::MANTISSA_RADIX_SHIFT;
format |= (unwrap_or_zero(self.exponent_base) as u128) << flags::EXPONENT_BASE_SHIFT;
format |= (unwrap_or_zero(self.exponent_radix) as u128) << flags::EXPONENT_RADIX_SHIFT;
format
}
/// Build the packed number format, panicking if the builder is invalid.
///
/// # Panics
///
/// If the built format is not valid. This should always
/// be used within a const context to avoid panics at runtime.
#[inline(always)]
pub const fn build_strict(&self) -> u128 {
use crate::format::format_error_impl;
let packed = self.build_unchecked();
match format_error_impl(packed) {
Error::Success => packed,
error => core::panic!("{}", error.description()),
}
}
/// Create 128-bit, packed number format struct from builder options.
///
/// <div class="warning">
///
/// This function will never fail. It is up to the caller to ensure the
/// format is valid using [`NumberFormat::is_valid`]. This function is
/// soft-deprecated and you should prefer [`build_unchecked`] and handle
/// if the result is invalid instead, or use [`build_strict`] to panic on
/// any errors. This exists when compatibility with older Rust
/// versions was required.
///
/// </div>
///
/// [`build_unchecked`]: Self::build_unchecked
/// [`build_strict`]: Self::build_strict
/// [`NumberFormat::is_valid`]: crate::NumberFormat::is_valid
#[inline(always)]
#[deprecated = "Use `build_strict` or `build_unchecked` instead."]
pub const fn build(&self) -> u128 {
self.build_unchecked()
}
/// Re-create builder from format.
#[inline(always)]
pub const fn rebuild(format: u128) -> Self {
NumberFormatBuilder {
digit_separator: num::NonZeroU8::new(flags::digit_separator(format)),
base_prefix: num::NonZeroU8::new(flags::base_prefix(format)),
base_suffix: num::NonZeroU8::new(flags::base_suffix(format)),
mantissa_radix: flags::mantissa_radix(format) as u8,
exponent_base: num::NonZeroU8::new(flags::exponent_base(format) as u8),
exponent_radix: num::NonZeroU8::new(flags::exponent_radix(format) as u8),
required_integer_digits: has_flag!(format, REQUIRED_INTEGER_DIGITS),
required_fraction_digits: has_flag!(format, REQUIRED_FRACTION_DIGITS),
required_exponent_digits: has_flag!(format, REQUIRED_EXPONENT_DIGITS),
required_mantissa_digits: has_flag!(format, REQUIRED_MANTISSA_DIGITS),
no_positive_mantissa_sign: has_flag!(format, NO_POSITIVE_MANTISSA_SIGN),
required_mantissa_sign: has_flag!(format, REQUIRED_MANTISSA_SIGN),
no_exponent_notation: has_flag!(format, NO_EXPONENT_NOTATION),
no_positive_exponent_sign: has_flag!(format, NO_POSITIVE_EXPONENT_SIGN),
required_exponent_sign: has_flag!(format, REQUIRED_EXPONENT_SIGN),
no_exponent_without_fraction: has_flag!(format, NO_EXPONENT_WITHOUT_FRACTION),
no_special: has_flag!(format, NO_SPECIAL),
case_sensitive_special: has_flag!(format, CASE_SENSITIVE_SPECIAL),
no_integer_leading_zeros: has_flag!(format, NO_INTEGER_LEADING_ZEROS),
no_float_leading_zeros: has_flag!(format, NO_FLOAT_LEADING_ZEROS),
required_exponent_notation: has_flag!(format, REQUIRED_EXPONENT_NOTATION),
case_sensitive_exponent: has_flag!(format, CASE_SENSITIVE_EXPONENT),
case_sensitive_base_prefix: has_flag!(format, CASE_SENSITIVE_BASE_PREFIX),
case_sensitive_base_suffix: has_flag!(format, CASE_SENSITIVE_BASE_SUFFIX),
integer_internal_digit_separator: has_flag!(format, INTEGER_INTERNAL_DIGIT_SEPARATOR),
fraction_internal_digit_separator: has_flag!(format, FRACTION_INTERNAL_DIGIT_SEPARATOR),
exponent_internal_digit_separator: has_flag!(format, EXPONENT_INTERNAL_DIGIT_SEPARATOR),
integer_leading_digit_separator: has_flag!(format, INTEGER_LEADING_DIGIT_SEPARATOR),
fraction_leading_digit_separator: has_flag!(format, FRACTION_LEADING_DIGIT_SEPARATOR),
exponent_leading_digit_separator: has_flag!(format, EXPONENT_LEADING_DIGIT_SEPARATOR),
integer_trailing_digit_separator: has_flag!(format, INTEGER_TRAILING_DIGIT_SEPARATOR),
fraction_trailing_digit_separator: has_flag!(format, FRACTION_TRAILING_DIGIT_SEPARATOR),
exponent_trailing_digit_separator: has_flag!(format, EXPONENT_TRAILING_DIGIT_SEPARATOR),
integer_consecutive_digit_separator: has_flag!(
format,
INTEGER_CONSECUTIVE_DIGIT_SEPARATOR
),
fraction_consecutive_digit_separator: has_flag!(
format,
FRACTION_CONSECUTIVE_DIGIT_SEPARATOR
),
exponent_consecutive_digit_separator: has_flag!(
format,
EXPONENT_CONSECUTIVE_DIGIT_SEPARATOR
),
special_digit_separator: has_flag!(format, SPECIAL_DIGIT_SEPARATOR),
}
}
}
impl Default for NumberFormatBuilder {
#[inline(always)]
fn default() -> Self {
Self::new()
}
}
