1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

//! Pre-defined constants for numeric types.

#![cfg(feature = "write")]

#[cfg(feature = "f16")]
use crate::bf16::bf16;
#[cfg(feature = "f16")]
use crate::f16::f16;

/// The size, in bytes, of formatted values.
pub trait FormattedSize {
    /// Maximum number of bytes required to serialize a number to string.
    ///
    /// Note that this value may be insufficient if digit precision control,
    /// exponent break points, or disabling exponent notation is used. If
    /// you are changing the number significant digits written, the exponent
    /// break points, or disabling scientific notation, you will need a larger
    /// buffer than the one provided. An upper limit on the buffer size can
    /// then be determined using [`WriteOptions::buffer_size`].
    ///
    /// [`WriteOptions::buffer_size`]: crate::options::WriteOptions::buffer_size
    /// [`lexical_write_float`]: https://github.com/Alexhuszagh/rust-lexical/tree/main/lexical-write-float
    const FORMATTED_SIZE: usize;

    /// Maximum number of bytes required to serialize a number to a decimal
    /// string.
    ///
    /// Note that this value may be insufficient if digit precision control,
    /// exponent break points, or disabling exponent notation is used. If
    /// you are changing the number significant digits written, the exponent
    /// break points, or disabling scientific notation, you will need a larger
    /// buffer than the one provided. An upper limit on the buffer size can
    /// then be determined using [`WriteOptions::buffer_size`].
    ///
    /// [`WriteOptions::buffer_size`]: crate::options::WriteOptions::buffer_size
    /// [`lexical_write_float`]: https://github.com/Alexhuszagh/rust-lexical/tree/main/lexical-write-float
    const FORMATTED_SIZE_DECIMAL: usize;
}

macro_rules! formatted_size_impl {
    ($($t:tt $decimal:literal $radix:literal ; )*) => ($(
        impl FormattedSize for $t {
            #[cfg(feature = "power-of-two")]
            const FORMATTED_SIZE: usize = $radix;
            #[cfg(not(feature = "power-of-two"))]
            const FORMATTED_SIZE: usize = $decimal;
            const FORMATTED_SIZE_DECIMAL: usize = $decimal;
        }
    )*);
}

formatted_size_impl! {
    i8 4 16 ;
    i16 6 32 ;
    i32 11 64 ;
    i64 20 128 ;
    i128 40 256 ;
    u8 3 16 ;
    u16 5 32 ;
    u32 10 64 ;
    u64 20 128 ;
    u128 39 256 ;
    // The f64 buffer is actually a size of 60, but use 64 since it's a power of 2.
    // Use 256 for non-decimal values, actually, since we seem to have memory
    // issues with f64. Clearly not sufficient memory allocated for non-decimal
    // values.
    //bf16 64 256 ;
    //f16 64 256 ;
    f32 64 256 ;
    f64 64 256 ;
    //f128 128 512 ;
    //f256 256 1024 ;
}

#[cfg(feature = "f16")]
formatted_size_impl! {
    f16 64 256 ;
    bf16 64 256 ;
}

#[cfg(target_pointer_width = "16")]
formatted_size_impl! { isize 6 32 ; }
#[cfg(target_pointer_width = "16")]
formatted_size_impl! { usize 5 32 ; }

#[cfg(target_pointer_width = "32")]
formatted_size_impl! { isize 11 64 ; }
#[cfg(target_pointer_width = "32")]
formatted_size_impl! { usize 10 64 ; }

#[cfg(target_pointer_width = "64")]
formatted_size_impl! { isize 20 128 ; }
#[cfg(target_pointer_width = "64")]
formatted_size_impl! { usize 20 128 ; }

/// Maximum number of bytes required to serialize any number to string.
///
/// Note that this value may be insufficient if digit precision control,
/// exponent break points, or disabling exponent notation is used.
/// Please read the documentation in [`lexical_write_float`] for more
/// information.
///
/// [`lexical_write_float`]: https://github.com/Alexhuszagh/rust-lexical/tree/main/lexical-write-float
pub const BUFFER_SIZE: usize = f64::FORMATTED_SIZE;