twibint 0.3.2

Crate for arithmetic on arbitrarily large integers. Provides Python bindings as well.
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
56
57
58

use pyo3::exceptions::PyValueError;
use pyo3::prelude::*;

use crate::errors::{DivisionError, FromFloatError, UnexpectedCharacterError};

/// Trait to get the name of an error type as a string, as a static method. \
/// Must be implemented for any error type that will flow into Python.
trait ErrorTypeToString {
    fn str() -> String;
}

/// py_value_error: with an error message as a `&str`, and an error type
/// as a generic parameter, will return a Python `ValueError` with a message
/// containing the original message, plus the error type name.
fn py_value_error<ErrorType: ErrorTypeToString>(msg: &str) -> pyo3::PyErr {
    let mut string = ErrorType::str();
    string.push_str(": ");
    string.push_str(msg);
    PyErr::new::<PyValueError, _>(string)
}

/// Get the `UnexpectedCharacterError` name as a string
impl ErrorTypeToString for UnexpectedCharacterError {
    fn str() -> String {
        "UnexpectedCharacterError: ".to_string()
    }
}
/// Get the `DivisionByZero` name as a string
impl ErrorTypeToString for DivisionError {
    fn str() -> String {
        "DivisionError: ".to_string()
    }
}
/// Get the `FromFloatError` name as a string
impl<T> ErrorTypeToString for FromFloatError<T> {
    fn str() -> String {
        "FromFloatError: ".to_string()
    }
}

/// Converts a `UnexpectedCharacterError` to a `ValueError`
impl From<UnexpectedCharacterError> for pyo3::PyErr {
    fn from(e: UnexpectedCharacterError) -> Self {
        py_value_error::<DivisionError>(&e.to_string())
    }
}
/// Converts a `DivisionByZero` to a `ValueError`
impl From<DivisionError> for pyo3::PyErr {
    fn from(e: DivisionError) -> Self {
        py_value_error::<DivisionError>(&e.to_string())
    }
}
/// Converts a `FromFloatError` to a `ValueError`
impl<T: std::fmt::Display> From<FromFloatError<T>> for pyo3::PyErr {
    fn from(e: FromFloatError<T>) -> Self {
        py_value_error::<FromFloatError<T>>(&e.to_string())
    }
}