sj 2.0.3

/*
==--==--==--==--==--==--==--==--==--==--==--==--==--==--==--==--

SJ

Copyright (C) 2019-2025  Anonymous

There are several releases over multiple years,
they are listed as ranges, such as: "2019-2025".

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>.

::--::--::--::--::--::--::--::--::--::--::--::--::--::--::--::--
*/

//! # Number writer

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

use {
    core::fmt::{self, Debug, Formatter},
    std::io::Write,
    crate::IoResult,
    super::{Kind, Number},
};

const BUF_LAST_IDX: usize = super::MAX_INT_DIGITS - 1;

const I64_MIN_VALUE: &[u8] = b"-9223372036854775808";
const I128_MIN_VALUE: &[u8] = b"-170141183460469231731687303715884105728";

const DIGITS: &str = concat!(
    "000001002003004005006007008009010011012013014015016017018019020021022023024025026027028029030031032033034035036037038039040041042043044",
    "045046047048049050051052053054055056057058059060061062063064065066067068069070071072073074075076077078079080081082083084085086087088089",
    "090091092093094095096097098099100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134",
    "135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179",
    "180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224",
    "225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269",
    "270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314",
    "315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359",
    "360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404",
    "405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449",
    "450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494",
    "495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539",
    "540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584",
    "585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629",
    "630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674",
    "675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719",
    "720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764",
    "765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809",
    "810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854",
    "855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899",
    "900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944",
    "945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989",
    "990991992993994995996997998999",
);

#[test]
fn test_digits() {
    for i in 0..=999 {
        let s = alloc::format!("{:03}", i);
        let i = i * 3;
        assert_eq!(s, &DIGITS[i .. i + 3]);
    }
}

macro_rules! write_unsigned { ($buf: expr, $n: expr, $negative: expr, $stream: ident) => {{
    let digits = DIGITS.as_bytes();
    let top = 1_000;
    let mut n = $n;
    let mut i = BUF_LAST_IDX;
    while n >= top {
        let idx = (n % top) as usize * 3;
        $buf[i] = digits[idx + 2];
        i -= 1;
        $buf[i] = digits[idx + 1];
        i -= 1;
        $buf[i] = digits[idx];
        i -= 1;
        n /= top;
    }
    match n {
        0..=9 => $buf[i] = (n as u8) + b'0',
        _ => {
            let idx = (n as usize) * 3;
            $buf[i] = digits[idx + 2];
            i -= 1;
            $buf[i] = digits[idx + 1];
            if n >= 100 {
                i -= 1;
                $buf[i] = digits[idx];
            }
        },
    };
    if $negative {
        i -= 1;
        $buf[i] = b'-';
    }
    $stream.write_all(&$buf[i..])
}}}

macro_rules! write_signed { ($buf: expr, $ty: ty, $min_value: ident, $n: expr, $stream: ident) => {{
    let n = $n;
    if n == <$ty>::min_value() {
        return $stream.write_all($min_value);
    }

    let negative = n.is_negative();
    write_unsigned!($buf, n.abs(), negative, $stream)
}}}

/// # Number writer
pub (crate) struct NumberWriter {
    buf: [u8; super::MAX_INT_DIGITS],
}

impl NumberWriter {

    /// # Makes new instance
    pub fn new() -> Self {
        Self {
            buf: [0; super::MAX_INT_DIGITS],
        }
    }

    /// # Writes a number into a stream
    pub fn write<W>(&mut self, n: &Number, stream: &mut W) -> IoResult<()> where W: Write {
        match n.kind {
            Kind::I64 => write_signed!(self.buf, i64, I64_MIN_VALUE, n.as_i64(), stream),
            Kind::I128 => write_signed!(self.buf, i128, I128_MIN_VALUE, n.as_i128(), stream),

            Kind::U64 => write_unsigned!(self.buf, n.as_u64(), false, stream),
            Kind::U128 => write_unsigned!(self.buf, n.as_u128(), false, stream),

            Kind::F32 => write!(stream, concat!('{', '}'), n.as_f32()),
            Kind::F64 => write!(stream, concat!('{', '}'), n.as_f64()),
        }
    }

}

impl Debug for NumberWriter {

    fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
        write!(f, "NumberWriter {{ buf: {:?} }}", &self.buf[..])
    }

}

#[test]
fn tests() -> IoResult<()> {
    use alloc::{
        string::ToString,
        vec::Vec,
    };

    assert_eq!(i64::min_value().to_string().as_bytes(), I64_MIN_VALUE);
    assert_eq!(i128::min_value().to_string().as_bytes(), I128_MIN_VALUE);

    let mut buf = Vec::with_capacity(super::MAX_INT_DIGITS);
    let mut nw = NumberWriter::new();
    for i in 0_u8..99 {
        buf.clear();
        let n = Number::from(i);
        nw.write(&n, &mut buf)?;
        assert_eq!(i.to_string().as_bytes(), buf.as_slice());

        buf.clear();
        let n = Number::from(-i8::try_from(i).unwrap());
        nw.write(&n, &mut buf)?;
        assert_eq!((-i8::try_from(i).unwrap()).to_string().as_bytes(), buf.as_slice());

        buf.clear();
        let n = Number::from(u64::max_value() - u64::from(i));
        nw.write(&n, &mut buf)?;
        assert_eq!(n.to_string().as_bytes(), buf.as_slice());

        buf.clear();
        let n = Number::from(u128::max_value() - u128::from(i));
        nw.write(&n, &mut buf)?;
        assert_eq!(n.to_string().as_bytes(), buf.as_slice());

        buf.clear();
        let n = Number::from(i64::min_value() + i64::from(i));
        nw.write(&n, &mut buf)?;
        assert_eq!(n.to_string().as_bytes(), buf.as_slice());

        buf.clear();
        let n = Number::from(i128::min_value() + i128::from(i));
        nw.write(&n, &mut buf)?;
        assert_eq!(n.to_string().as_bytes(), buf.as_slice());
    }

    Ok(())
}