lexical-write-integer 1.0.6

//! Shared trait and methods for writing integers.

#![doc(hidden)]

use lexical_util::format;

/// Select the back-end.
#[cfg(feature = "compact")]
use crate::compact::Compact;
#[cfg(not(feature = "compact"))]
use crate::decimal::Decimal;
#[cfg(all(not(feature = "compact"), feature = "power-of-two"))]
use crate::radix::Radix;

/// Define the implementation to write significant digits.
macro_rules! write_mantissa {
    ($($t:tt)+) => {
        /// Internal implementation to write significant digits for float writers.
        #[doc(hidden)]
        #[inline(always)]
        fn write_mantissa<const FORMAT: u128>(self, buffer: &mut [u8]) -> usize {
            self.write_integer::<FORMAT, { format::RADIX }, { format::RADIX_SHIFT }>(buffer)
        }

        /// Internal implementation to write significant digits for float writers.
        #[doc(hidden)]
        #[inline(always)]
        fn write_mantissa_signed<const FORMAT: u128>(self, buffer: &mut [u8]) -> usize {
            self.write_integer_signed::<FORMAT, { format::RADIX }, { format::RADIX_SHIFT }>(buffer)
        }
    };
}

/// Define the implementation to write exponent digits.
macro_rules! write_exponent {
    ($($t:tt)+) => (
        // NOTE: This should always be signed, but for backwards compatibility as
        // a precaution we keep the original just in case someone uses the private API.

        /// Internal implementation to write exponent digits for float writers.
        // NOTE: This is not part of the public API.
        #[doc(hidden)]
        #[inline(always)]
        #[deprecated = "use `write_exponent_signed`, since exponents are always signed."]
        fn write_exponent<const FORMAT: u128>(self, buffer: &mut [u8]) -> usize
        {
            self.write_integer::<FORMAT, { format::EXPONENT_RADIX }, { format::EXPONENT_RADIX_SHIFT }>(buffer)
        }

        /// Internal implementation to write exponent digits for float writers.
        #[doc(hidden)]
        #[inline(always)]
        fn write_exponent_signed<const FORMAT: u128>(self, buffer: &mut [u8]) -> usize
        {
            self.write_integer_signed::<FORMAT, { format::EXPONENT_RADIX }, { format::EXPONENT_RADIX_SHIFT }>(buffer)
        }
    )
}

/// Write integer trait, implemented in terms of the compact back-end.
#[cfg(feature = "compact")]
pub trait WriteInteger: Compact {
    /// Forward write integer parameters to an unoptimized backend.
    ///
    /// # Preconditions
    ///
    /// `self` must be non-negative and unsigned.
    ///
    /// [`FORMATTED_SIZE`]: lexical_util::constants::FormattedSize::FORMATTED_SIZE
    /// [`FORMATTED_SIZE_DECIMAL`]: lexical_util::constants::FormattedSize::FORMATTED_SIZE_DECIMAL
    fn write_integer<const FORMAT: u128, const MASK: u128, const SHIFT: i32>(
        self,
        buffer: &mut [u8],
    ) -> usize {
        let radix = format::radix_from_flags(FORMAT, MASK, SHIFT);
        self.compact(radix, buffer)
    }

    /// Forward write integer parameters to an optimized backend.
    ///
    /// This requires a type that was previously signed.
    ///
    /// # Preconditions
    ///
    /// `self` must be non-negative but is `>= 0` and `<= Signed::MAX`.
    ///
    /// [`FORMATTED_SIZE_DECIMAL`]: lexical_util::constants::FormattedSize::FORMATTED_SIZE_DECIMAL
    #[inline(always)]
    fn write_integer_signed<const FORMAT: u128, const MASK: u128, const SHIFT: i32>(
        self,
        buffer: &mut [u8],
    ) -> usize {
        self.write_integer::<FORMAT, MASK, SHIFT>(buffer)
    }

    write_mantissa!(Compact);
    write_exponent!(Compact);
}

/// Write integer trait, implemented in terms of the optimized, decimal
/// back-end.
#[cfg(all(not(feature = "compact"), not(feature = "power-of-two")))]
pub trait WriteInteger: Decimal {
    /// Forward write integer parameters to an optimized backend.
    ///
    /// # Preconditions
    ///
    /// `self` must be non-negative and unsigned.
    ///
    /// [`FORMATTED_SIZE_DECIMAL`]: lexical_util::constants::FormattedSize::FORMATTED_SIZE_DECIMAL
    #[inline(always)]
    fn write_integer<const __: u128, const ___: u128, const ____: i32>(
        self,
        buffer: &mut [u8],
    ) -> usize {
        self.decimal(buffer)
    }

    /// Forward write integer parameters to an optimized backend.
    ///
    /// This requires a type that was previously signed.
    ///
    /// # Preconditions
    ///
    /// `self` must be non-negative but is `>= 0` and `<= Signed::MAX`.
    ///
    /// [`FORMATTED_SIZE_DECIMAL`]: lexical_util::constants::FormattedSize::FORMATTED_SIZE_DECIMAL
    #[inline(always)]
    fn write_integer_signed<const __: u128, const ___: u128, const ____: i32>(
        self,
        buffer: &mut [u8],
    ) -> usize {
        self.decimal_signed(buffer)
    }

    write_mantissa!(Decimal);
    write_exponent!(Decimal);
}

/// Write integer trait, implemented in terms of the optimized, decimal or radix
/// back-end.
#[cfg(all(not(feature = "compact"), feature = "power-of-two"))]
pub trait WriteInteger: Decimal + Radix {
    /// Forward write integer parameters to an optimized backend.
    ///
    /// # Preconditions
    ///
    /// `self` must be non-negative and unsigned.
    ///
    /// [`FORMATTED_SIZE`]: lexical_util::constants::FormattedSize::FORMATTED_SIZE
    /// [`FORMATTED_SIZE_DECIMAL`]: lexical_util::constants::FormattedSize::FORMATTED_SIZE_DECIMAL
    #[inline(always)]
    fn write_integer<const FORMAT: u128, const MASK: u128, const SHIFT: i32>(
        self,
        buffer: &mut [u8],
    ) -> usize {
        if format::radix_from_flags(FORMAT, MASK, SHIFT) == 10 {
            self.decimal(buffer)
        } else {
            self.radix::<FORMAT, MASK, SHIFT>(buffer)
        }
    }

    /// Forward write integer parameters to an optimized backend.
    ///
    /// This requires a type that was previously signed.
    ///
    /// # Preconditions
    ///
    /// `self` must be non-negative but is `>= 0` and `<= Signed::MAX`.
    ///
    /// [`FORMATTED_SIZE_DECIMAL`]: lexical_util::constants::FormattedSize::FORMATTED_SIZE_DECIMAL
    #[inline(always)]
    fn write_integer_signed<const FORMAT: u128, const MASK: u128, const SHIFT: i32>(
        self,
        buffer: &mut [u8],
    ) -> usize {
        if format::radix_from_flags(FORMAT, MASK, SHIFT) == 10 {
            self.decimal_signed(buffer)
        } else {
            self.radix::<FORMAT, MASK, SHIFT>(buffer)
        }
    }

    write_mantissa!(Decimal + Radix);
    write_exponent!(Decimal + Radix);
}

macro_rules! write_integer_impl {
    ($($t:ty)*) => ($(
        impl WriteInteger for $t {}
    )*)
}

write_integer_impl! { u8 u16 u32 u64 u128 usize }