diff options
Diffstat (limited to 'vendor/numtoa-0.1.0')
| -rw-r--r-- | vendor/numtoa-0.1.0/.cargo-checksum.json | 1 | ||||
| -rw-r--r-- | vendor/numtoa-0.1.0/Cargo.toml | 26 | ||||
| -rw-r--r-- | vendor/numtoa-0.1.0/LICENSE-APACHE | 202 | ||||
| -rw-r--r-- | vendor/numtoa-0.1.0/LICENSE-MIT | 21 | ||||
| -rw-r--r-- | vendor/numtoa-0.1.0/README.md | 65 | ||||
| -rw-r--r-- | vendor/numtoa-0.1.0/src/lib.rs | 540 |
6 files changed, 855 insertions, 0 deletions
diff --git a/vendor/numtoa-0.1.0/.cargo-checksum.json b/vendor/numtoa-0.1.0/.cargo-checksum.json new file mode 100644 index 00000000..0155eb3a --- /dev/null +++ b/vendor/numtoa-0.1.0/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"Cargo.toml":"4e13b8b2df85c3700056bf852bbc0d75973b5c67d3450c0f9c949c162783d85b","LICENSE-APACHE":"c95bae1d1ce0235ecccd3560b772ec1efb97f348a79f0fbe0a634f0c2ccefe2c","LICENSE-MIT":"fce969aafe49874e25d602153abe60a686ab37a7c97ff36ba4cfd270337ef7e0","README.md":"5c788c039c47e327abed0d61b1a7157851c914e33689716ec9c848cbd9baf013","src/lib.rs":"fd812addca5e63c49bd0d480be72a14bdd50f7fa78044b7796f38b8b9d911d72"},"package":"b8f8bdf33df195859076e54ab11ee78a1b208382d3a26ec40d142ffc1ecc49ef"}
\ No newline at end of file diff --git a/vendor/numtoa-0.1.0/Cargo.toml b/vendor/numtoa-0.1.0/Cargo.toml new file mode 100644 index 00000000..7a026a1b --- /dev/null +++ b/vendor/numtoa-0.1.0/Cargo.toml @@ -0,0 +1,26 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g. crates.io) dependencies +# +# If you believe there's an error in this file please file an +# issue against the rust-lang/cargo repository. If you're +# editing this file be aware that the upstream Cargo.toml +# will likely look very different (and much more reasonable) + +[package] +name = "numtoa" +version = "0.1.0" +authors = ["Michael Aaron Murphy <mmstickman@gmail.com>"] +description = "Convert numbers into stack-allocated byte arrays" +documentation = "https://docs.rs/numtoa" +readme = "README.md" +keywords = ["numbers", "convert", "numtoa", "itoa", "no_std"] +categories = ["value-formatting"] +license = "MIT OR Apache-2.0" +repository = "https://gitlab.com/mmstick/numtoa" + +[features] +std = [] diff --git a/vendor/numtoa-0.1.0/LICENSE-APACHE b/vendor/numtoa-0.1.0/LICENSE-APACHE new file mode 100644 index 00000000..57bc88a1 --- /dev/null +++ b/vendor/numtoa-0.1.0/LICENSE-APACHE @@ -0,0 +1,202 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + diff --git a/vendor/numtoa-0.1.0/LICENSE-MIT b/vendor/numtoa-0.1.0/LICENSE-MIT new file mode 100644 index 00000000..492da631 --- /dev/null +++ b/vendor/numtoa-0.1.0/LICENSE-MIT @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2017 Michael Aaron Murphy <mmstickman@gmail.com> + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/vendor/numtoa-0.1.0/README.md b/vendor/numtoa-0.1.0/README.md new file mode 100644 index 00000000..497e906a --- /dev/null +++ b/vendor/numtoa-0.1.0/README.md @@ -0,0 +1,65 @@ +# NumToA + +## `#![no_std]` Compatible with Zero Heap Allocations + +The standard library provides a convenient method of converting numbers into strings, but these strings are +heap-allocated. If you have an application which needs to convert large volumes of numbers into strings, but don't +want to pay the price of heap allocation, this crate provides an efficient `no_std`-compatible method of heaplessly converting numbers +into their string representations, storing the representation within a reusable byte array. + +## Supports Multiple Bases + +In addition to supporting the standard base 10 conversion, this implementation allows you to select the base of +your choice. Therefore, if you want a binary representation, set the base to 2. If you want hexadecimal, set the +base to 16. + +## No Unsafe + +Both the standard library and itoa crate rely on unsafe functions, but this implementation has been able to avoid +the use of unsafe entirely. + +## Fast + +Performance is roughly identical to that of the `itoa` crate when performing base 10 conversions. Below is a benchmark +of printing 0 through 5,000,000 to `/dev/null` + +``` +std: 1150615048 ns +itoa: 838556714 ns +numtoa: 825544518 ns +``` + +## Base 10 Example + +```rust +use numtoa::NumToA; +use std::io::{self, Write}; + +let stdout = io::stdout(); +let mut stdout = stdout.lock(); +let mut buffer = [0u8; 20]; + +let number: u32 = 162392; +let mut start_index = number.numtoa(10, &mut buffer); +let _ = stdout.write(&buffer[start_index..]); +let _ = stdout.write(b"\n"); +assert_eq!(&buffer[start_index..], b"162392"); + +let other_number: i32 = -6235; +start_index = other_number.numtoa(10, &mut buffer); +let _ = stdout.write(&buffer[start_index..]); +let _ = stdout.write(b"\n"); +assert_eq!(&buffer[start_index..], b"-6235"); + +let large_num: u64 = 35320842; +start_index = large_num.numtoa(10, &mut buffer); +let _ = stdout.write(&buffer[start_index..]); +let _ = stdout.write(b"\n"); +assert_eq!(&buffer[start_index..], b"35320842"); + +let max_u64: u64 = 18446744073709551615; +start_index = max_u64.numtoa(10, &mut buffer); +let _ = stdout.write(&buffer[start_index..]); +let _ = stdout.write(b"\n"); +assert_eq!(&buffer[start_index..], b"18446744073709551615"); +``` diff --git a/vendor/numtoa-0.1.0/src/lib.rs b/vendor/numtoa-0.1.0/src/lib.rs new file mode 100644 index 00000000..c15b23f0 --- /dev/null +++ b/vendor/numtoa-0.1.0/src/lib.rs @@ -0,0 +1,540 @@ +//! The standard library provides a convenient method of converting numbers into strings, but these strings are +//! heap-allocated. If you have an application which needs to convert large volumes of numbers into strings, but don't +//! want to pay the price of heap allocation, this crate provides an efficient `no_std`-compatible method of heaplessly converting numbers +//! into their string representations, storing the representation within a reusable byte array. +//! +//! In addition to supporting the standard base 10 conversion, this implementation allows you to select the base of +//! your choice. Therefore, if you want a binary representation, set the base to 2. If you want hexadecimal, set the +//! base to 16. +//! +//! # Convenience Example +//! +//! ``` +//! use numtoa::NumToA; +//! +//! let mut buf = [0u8; 20]; +//! let mut string = String::new(); +//! +//! for number in (1..10) { +//! string.push_str(number.numtoa_str(10, &mut buf)); +//! string.push('\n'); +//! } +//! +//! println!("{}", string); +//! ``` +//! +//! ## Base 10 Example +//! ``` +//! use numtoa::NumToA; +//! use std::io::{self, Write}; +//! +//! let stdout = io::stdout(); +//! let mut stdout = stdout.lock(); +//! let mut buffer = [0u8; 20]; +//! +//! let number: u32 = 162392; +//! let mut start_indice = number.numtoa(10, &mut buffer); +//! let _ = stdout.write(&buffer[start_indice..]); +//! let _ = stdout.write(b"\n"); +//! assert_eq!(&buffer[start_indice..], b"162392"); +//! +//! let other_number: i32 = -6235; +//! start_indice = other_number.numtoa(10, &mut buffer); +//! let _ = stdout.write(&buffer[start_indice..]); +//! let _ = stdout.write(b"\n"); +//! assert_eq!(&buffer[start_indice..], b"-6235"); +//! +//! let other_number: i8 = -128; +//! start_indice = other_number.numtoa(10, &mut buffer); +//! let _ = stdout.write(&buffer[start_indice..]); +//! let _ = stdout.write(b"\n"); +//! assert_eq!(&buffer[start_indice..], b"-128"); +//! +//! let other_number: i8 = 53; +//! start_indice = other_number.numtoa(10, &mut buffer); +//! let _ = stdout.write(&buffer[start_indice..]); +//! let _ = stdout.write(b"\n"); +//! assert_eq!(&buffer[start_indice..], b"53"); +//! +//! let other_number: i16 = -256; +//! start_indice = other_number.numtoa(10, &mut buffer); +//! let _ = stdout.write(&buffer[start_indice..]); +//! let _ = stdout.write(b"\n"); +//! assert_eq!(&buffer[start_indice..], b"-256"); +//! +//! let other_number: i16 = -32768; +//! start_indice = other_number.numtoa(10, &mut buffer); +//! let _ = stdout.write(&buffer[start_indice..]); +//! let _ = stdout.write(b"\n"); +//! assert_eq!(&buffer[start_indice..], b"-32768"); +//! +//! let large_num: u64 = 35320842; +//! start_indice = large_num.numtoa(10, &mut buffer); +//! let _ = stdout.write(&buffer[start_indice..]); +//! let _ = stdout.write(b"\n"); +//! assert_eq!(&buffer[start_indice..], b"35320842"); +//! +//! let max_u64: u64 = 18446744073709551615; +//! start_indice = max_u64.numtoa(10, &mut buffer); +//! let _ = stdout.write(&buffer[start_indice..]); +//! let _ = stdout.write(b"\n"); +//! assert_eq!(&buffer[start_indice..], b"18446744073709551615"); +//! ``` + +#![no_std] +use core::mem::size_of; + +#[cfg(feature = "std")] +extern crate std; +#[cfg(feature = "std")] +use std::str; + +/// Converts a number into a string representation, storing the conversion into a mutable byte slice. +pub trait NumToA<T> { + /// Given a base for encoding and a mutable byte slice, write the number into the byte slice and return the + /// indice where the inner string begins. The inner string can be extracted by slicing the byte slice from + /// that indice. + /// + /// # Panics + /// If the supplied buffer is smaller than the number of bytes needed to write the integer, this will panic. + /// On debug builds, this function will perform a check on base 10 conversions to ensure that the input array + /// is large enough to hold the largest possible value in digits. + /// + /// # Example + /// ``` + /// use numtoa::NumToA; + /// use std::io::{self, Write}; + /// + /// let stdout = io::stdout(); + /// let stdout = &mut io::stdout(); + /// + /// let mut buffer = [0u8; 20]; + /// let number = 15325; + /// let start_indice = number.numtoa(10, &mut buffer); + /// let _ = stdout.write(&buffer[start_indice..]); + /// assert_eq!(&buffer[start_indice..], b"15325"); + /// ``` + fn numtoa(self, base: T, string: &mut [u8]) -> usize; + + #[cfg(feature = "std")] + /// Convenience method for quickly getting a string from the input's array buffer. + fn numtoa_str(self, base: T, buf: &mut [u8; 20]) -> &str; +} + +// A lookup table to prevent the need for conditional branching +// The value of the remainder of each step will be used as the index +const LOOKUP: &[u8] = b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; + +// A lookup table optimized for decimal lookups. Each two indices represents one possible number. +const DEC_LOOKUP: &[u8; 200] = b"0001020304050607080910111213141516171819\ + 2021222324252627282930313233343536373839\ + 4041424344454647484950515253545556575859\ + 6061626364656667686970717273747576777879\ + 8081828384858687888990919293949596979899"; + +macro_rules! base_10 { + ($number:ident, $index:ident, $string:ident) => { + // Decode four characters at the same time + while $number > 9999 { + let rem = ($number % 10000) as u16; + let (frst, scnd) = ((rem / 100) * 2, (rem % 100) * 2); + $string[$index-3..$index-1].copy_from_slice(&DEC_LOOKUP[frst as usize..frst as usize+2]); + $string[$index-1..$index+1].copy_from_slice(&DEC_LOOKUP[scnd as usize..scnd as usize+2]); + $index = $index.wrapping_sub(4); + $number /= 10000; + } + + if $number > 999 { + let (frst, scnd) = (($number / 100) * 2, ($number % 100) * 2); + $string[$index-3..$index-1].copy_from_slice(&DEC_LOOKUP[frst as usize..frst as usize+2]); + $string[$index-1..$index+1].copy_from_slice(&DEC_LOOKUP[scnd as usize..scnd as usize+2]); + $index = $index.wrapping_sub(4); + } else if $number > 99 { + let section = ($number as u16 / 10) * 2; + $string[$index-2..$index].copy_from_slice(&DEC_LOOKUP[section as usize..section as usize+2]); + $string[$index] = LOOKUP[($number % 10) as usize]; + $index = $index.wrapping_sub(3); + } else if $number > 9 { + $number *= 2; + $string[$index-1..$index+1].copy_from_slice(&DEC_LOOKUP[$number as usize..$number as usize+2]); + $index = $index.wrapping_sub(2); + } else { + $string[$index] = LOOKUP[$number as usize]; + $index = $index.wrapping_sub(1); + } + } +} + +macro_rules! impl_unsized_numtoa_for { + ($t:ty) => { + impl NumToA<$t> for $t { + fn numtoa(mut self, base: $t, string: &mut [u8]) -> usize { + // Check if the buffer is large enough and panic on debug builds if it isn't + if cfg!(debug_assertions) { + if base == 10 { + match size_of::<$t>() { + 2 => debug_assert!(string.len() >= 5, "u16 base 10 conversions require at least 5 bytes"), + 4 => debug_assert!(string.len() >= 10, "u32 base 10 conversions require at least 10 bytes"), + 8 => debug_assert!(string.len() >= 20, "u64 base 10 conversions require at least 20 bytes"), + _ => unreachable!() + } + } + } + + let mut index = string.len() - 1; + if self == 0 { + string[index] = b'0'; + return index; + } + + if base == 10 { + // Convert using optimized base 10 algorithm + base_10!(self, index, string); + } else { + while self != 0 { + let rem = self % base; + string[index] = LOOKUP[rem as usize]; + index = index.wrapping_sub(1); + self /= base; + } + } + + index.wrapping_add(1) + } + + #[cfg(feature = "std")] + fn numtoa_str(self, base: $t, buf: &mut [u8; 20]) -> &str { + let s = self.numtoa(base, buf); + unsafe { str::from_utf8_unchecked(&buf[s..]) } + } + } + } +} + +macro_rules! impl_sized_numtoa_for { + ($t:ty) => { + impl NumToA<$t> for $t { + fn numtoa(mut self, base: $t, string: &mut [u8]) -> usize { + if cfg!(debug_assertions) { + if base == 10 { + match size_of::<$t>() { + 2 => debug_assert!(string.len() >= 6, "i16 base 10 conversions require at least 6 bytes"), + 4 => debug_assert!(string.len() >= 11, "i32 base 10 conversions require at least 11 bytes"), + 8 => debug_assert!(string.len() >= 20, "i64 base 10 conversions require at least 20 bytes"), + _ => unreachable!() + } + } + } + + let mut index = string.len() - 1; + let mut is_negative = false; + + if self < 0 { + is_negative = true; + self = match self.checked_abs() { + Some(value) => value, + None => { + let value = <$t>::max_value(); + string[index] = LOOKUP[((value % base + 1) % base) as usize]; + index -= 1; + value / base + ((value % base == base - 1) as $t) + } + }; + } else if self == 0 { + string[index] = b'0'; + return index; + } + + if base == 10 { + // Convert using optimized base 10 algorithm + base_10!(self, index, string); + } else { + while self != 0 { + let rem = self % base; + string[index] = LOOKUP[rem as usize]; + index = index.wrapping_sub(1); + self /= base; + } + } + + if is_negative { + string[index] = b'-'; + index = index.wrapping_sub(1); + } + + index.wrapping_add(1) + } + + #[cfg(feature = "std")] + fn numtoa_str(self, base: $t, buf: &mut [u8; 20]) -> &str { + let s = self.numtoa(base, buf); + unsafe { str::from_utf8_unchecked(&buf[s..]) } + } + } + } +} + +impl_sized_numtoa_for!(i16); +impl_sized_numtoa_for!(i32); +impl_sized_numtoa_for!(i64); +impl_sized_numtoa_for!(isize); +impl_unsized_numtoa_for!(u16); +impl_unsized_numtoa_for!(u32); +impl_unsized_numtoa_for!(u64); +impl_unsized_numtoa_for!(usize); + +impl NumToA<i8> for i8 { + fn numtoa(mut self, base: i8, string: &mut [u8]) -> usize { + if cfg!(debug_assertions) { + if base == 10 { + debug_assert!(string.len() >= 4, "i8 conversions need at least 4 bytes"); + } + } + + let mut index = string.len() - 1; + let mut is_negative = false; + + if self < 0 { + is_negative = true; + self = match self.checked_abs() { + Some(value) => value, + None => { + let value = <i8>::max_value(); + string[index] = LOOKUP[((value % base + 1) % base) as usize]; + index -= 1; + value / base + ((value % base == base - 1) as i8) + } + }; + } else if self == 0 { + string[index] = b'0'; + return index; + } + + if base == 10 { + if self > 99 { + let section = (self / 10) * 2; + string[index-2..index].copy_from_slice(&DEC_LOOKUP[section as usize..section as usize+2]); + string[index] = LOOKUP[(self % 10) as usize]; + index = index.wrapping_sub(3); + } else if self > 9 { + self *= 2; + string[index-1..index+1].copy_from_slice(&DEC_LOOKUP[self as usize..self as usize+2]); + index = index.wrapping_sub(2); + } else { + string[index] = LOOKUP[self as usize]; + index = index.wrapping_sub(1); + } + } else { + while self != 0 { + let rem = self % base; + string[index] = LOOKUP[rem as usize]; + index = index.wrapping_sub(1); + self /= base; + } + } + + if is_negative { + string[index] = b'-'; + index = index.wrapping_sub(1); + } + + index.wrapping_add(1) + } + + #[cfg(feature = "std")] + fn numtoa_str(self, base: Self, buf: &mut [u8; 20]) -> &str { + let s = self.numtoa(base, buf); + unsafe { str::from_utf8_unchecked(&buf[s..]) } + } +} + +impl NumToA<u8> for u8 { + fn numtoa(mut self, base: u8, string: &mut [u8]) -> usize { + if cfg!(debug_assertions) { + if base == 10 { + debug_assert!(string.len() >= 3, "u8 conversions need at least 3 bytes"); + } + } + + let mut index = string.len() - 1; + if self == 0 { + string[index] = b'0'; + return index; + } + + if base == 10 { + if self > 99 { + let section = (self / 10) * 2; + string[index-2..index].copy_from_slice(&DEC_LOOKUP[section as usize..section as usize+2]); + string[index] = LOOKUP[(self % 10) as usize]; + index = index.wrapping_sub(3); + } else if self > 9 { + self *= 2; + string[index-1..index+1].copy_from_slice(&DEC_LOOKUP[self as usize..self as usize+2]); + index = index.wrapping_sub(2); + } else { + string[index] = LOOKUP[self as usize]; + index = index.wrapping_sub(1); + } + } else { + while self != 0 { + let rem = self % base; + string[index] = LOOKUP[rem as usize]; + index = index.wrapping_sub(1); + self /= base; + } + } + + index.wrapping_add(1) + } + + #[cfg(feature = "std")] + fn numtoa_str(self, base: Self, buf: &mut [u8; 20]) -> &str { + let s = self.numtoa(base, buf); + unsafe { str::from_utf8_unchecked(&buf[s..]) } + } +} + +#[test] +fn str_convenience() { + let mut buffer = [0u8; 20]; + assert_eq!("256123", 256123.numtoa_str(10, &mut buffer)); +} + +#[test] +#[should_panic] +fn base10_u8_array_too_small() { + let mut buffer = [0u8; 2]; + let _ = 0u8.numtoa(10, &mut buffer); +} + +#[test] +fn base10_u8_array_just_right() { + let mut buffer = [0u8; 3]; + let _ = 0u8.numtoa(10, &mut buffer); +} + +#[test] +#[should_panic] +fn base10_i8_array_too_small() { + let mut buffer = [0u8; 3]; + let _ = 0i8.numtoa(10, &mut buffer); +} + +#[test] +fn base10_i8_array_just_right() { + let mut buffer = [0u8; 4]; + let i = (-127i8).numtoa(10, &mut buffer); + assert_eq!(&buffer[i..], b"-127"); +} + +#[test] +#[should_panic] +fn base10_i16_array_too_small() { + let mut buffer = [0u8; 5]; + let _ = 0i16.numtoa(10, &mut buffer); +} + +#[test] +fn base10_i16_array_just_right() { + let mut buffer = [0u8; 6]; + let i = (-12768i16).numtoa(10, &mut buffer); + assert_eq!(&buffer[i..], b"-12768"); +} + +#[test] +#[should_panic] +fn base10_u16_array_too_small() { + let mut buffer = [0u8; 4]; + let _ = 0u16.numtoa(10, &mut buffer); +} + +#[test] +fn base10_u16_array_just_right() { + let mut buffer = [0u8; 5]; + let _ = 0u16.numtoa(10, &mut buffer); +} + +#[test] +#[should_panic] +fn base10_i32_array_too_small() { + let mut buffer = [0u8; 10]; + let _ = 0i32.numtoa(10, &mut buffer); +} + +#[test] +fn base10_i32_array_just_right() { + let mut buffer = [0u8; 11]; + let _ = 0i32.numtoa(10, &mut buffer); +} + +#[test] +#[should_panic] +fn base10_u32_array_too_small() { + let mut buffer = [0u8; 9]; + let _ = 0u32.numtoa(10, &mut buffer); +} + +#[test] +fn base10_u32_array_just_right() { + let mut buffer = [0u8; 10]; + let _ = 0u32.numtoa(10, &mut buffer); +} + +#[test] +#[should_panic] +fn base10_i64_array_too_small() { + let mut buffer = [0u8; 19]; + let _ = 0i64.numtoa(10, &mut buffer); +} + +#[test] +fn base10_i64_array_just_right() { + let mut buffer = [0u8; 20]; + let _ = 0i64.numtoa(10, &mut buffer); +} + +#[test] +#[should_panic] +fn base10_u64_array_too_small() { + let mut buffer = [0u8; 19]; + let _ = 0u64.numtoa(10, &mut buffer); +} + +#[test] +fn base10_u64_array_just_right() { + let mut buffer = [0u8; 20]; |