anyint 0.1.0

provides traits and structs for working with integers of any bit size
Documentation 
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

use core::num::IntErrorKind;

#[cfg(displaydoc)]
use displaydoc::Display;

/// The error type returned when a checked [`int`](anyint::int) conversion fails.
#[cfg_attr(
    std,
    error("out of range type conversion attempted"),
    derive(thiserror::Error)
)]
#[cfg_attr(displaydoc, derive(Display))]
#[derive(Debug, Copy, Clone, Eq, Hash, PartialEq, PartialOrd, Ord)]
pub enum OutOfRangeIntError {
    /// Integer is too large to store in target integer type.
    PosOverflow,
    /// Integer is too small to store in target integer type.
    NegOverflow,
}

impl From<OutOfRangeIntError> for ParseIntError {
    fn from(err: OutOfRangeIntError) -> Self {
        ParseIntError::OutOfRange(err)
    }
}

/// Enum to store the various types of errors that can cause parsing an integer to fail.
#[cfg_attr(std, derive(thiserror::Error))]
#[cfg_attr(displaydoc, derive(Display))]
#[derive(Debug, Copy, Clone, Eq, Hash, PartialEq, PartialOrd, Ord)]
pub enum ParseIntError {
    /// cannot parse integer from empty string
    Empty,

    /// invalid digit found in string
    InvalidDigit,

    /// Value {0} was too large or small to store in the target type.
    OutOfRange(OutOfRangeIntError),

    /// Unknown parsing error, this should never happen.
    Unknown,
}

impl From<IntErrorKind> for ParseIntError {
    fn from(kind: IntErrorKind) -> Self {
        match kind {
            IntErrorKind::Empty => ParseIntError::Empty,
            IntErrorKind::InvalidDigit => ParseIntError::InvalidDigit,
            IntErrorKind::NegOverflow => ParseIntError::OutOfRange(OutOfRangeIntError::NegOverflow),
            IntErrorKind::PosOverflow => ParseIntError::OutOfRange(OutOfRangeIntError::PosOverflow),
            _ => ParseIntError::Unknown,
        }
    }
}