pub trait FromPrimitive: Sized {
Show 14 methods
// Required methods
fn from_i64(n: i64) -> Option<Self>;
fn from_u64(n: u64) -> Option<Self>;
// Provided methods
fn from_isize(n: isize) -> Option<Self> { ... }
fn from_i8(n: i8) -> Option<Self> { ... }
fn from_i16(n: i16) -> Option<Self> { ... }
fn from_i32(n: i32) -> Option<Self> { ... }
fn from_i128(n: i128) -> Option<Self> { ... }
fn from_usize(n: usize) -> Option<Self> { ... }
fn from_u8(n: u8) -> Option<Self> { ... }
fn from_u16(n: u16) -> Option<Self> { ... }
fn from_u32(n: u32) -> Option<Self> { ... }
fn from_u128(n: u128) -> Option<Self> { ... }
fn from_f32(n: f32) -> Option<Self> { ... }
fn from_f64(n: f64) -> Option<Self> { ... }
}Expand description
A generic trait for converting a number to a value.
A value can be represented by the target type when it lies within
the range of scalars supported by the target type.
For example, a negative integer cannot be represented by an unsigned
integer type, and an i64 with a very high magnitude might not be
convertible to an i32.
On the other hand, conversions with possible precision loss or truncation
are admitted, like an f32 with a decimal part to an integer type, or
even a large f64 saturating to f32 infinity.
Required Methods§
Provided Methods§
Sourcefn from_isize(n: isize) -> Option<Self>
fn from_isize(n: isize) -> Option<Self>
Converts an isize to return an optional value of this type. If the
value cannot be represented by this type, then None is returned.
Sourcefn from_i8(n: i8) -> Option<Self>
fn from_i8(n: i8) -> Option<Self>
Converts an i8 to return an optional value of this type. If the
value cannot be represented by this type, then None is returned.
Sourcefn from_i16(n: i16) -> Option<Self>
fn from_i16(n: i16) -> Option<Self>
Converts an i16 to return an optional value of this type. If the
value cannot be represented by this type, then None is returned.
Sourcefn from_i32(n: i32) -> Option<Self>
fn from_i32(n: i32) -> Option<Self>
Converts an i32 to return an optional value of this type. If the
value cannot be represented by this type, then None is returned.
Sourcefn from_i128(n: i128) -> Option<Self>
fn from_i128(n: i128) -> Option<Self>
Converts an i128 to return an optional value of this type. If the
value cannot be represented by this type, then None is returned.
The default implementation converts through from_i64(). Types implementing
this trait should override this method if they can represent a greater range.
Sourcefn from_usize(n: usize) -> Option<Self>
fn from_usize(n: usize) -> Option<Self>
Converts a usize to return an optional value of this type. If the
value cannot be represented by this type, then None is returned.
Examples found in repository?
examples/example.rs (line 18)
11fn main() {
12 use enum_unitary::{FromPrimitive, ToPrimitive};
13
14 assert_eq!(enum_iterator::cardinality::<Myenum>(), 3);
15 assert_eq!(Into::<usize>::into (Myenum::A), 0);
16 assert_eq!(Into::<usize>::into (Myenum::B), 1);
17 assert_eq!(Into::<usize>::into (Myenum::C), 2);
18 assert_eq!(Some (Myenum::A), Myenum::from_usize (0));
19 assert_eq!(Some (Myenum::B), Myenum::from_usize (1));
20 assert_eq!(Some (Myenum::C), Myenum::from_usize (2));
21 assert_eq!(None, Myenum::from_usize (3));
22 assert_eq!(Some (0), Myenum::A.to_usize());
23 assert_eq!(Some (1), Myenum::B.to_usize());
24 assert_eq!(Some (2), Myenum::C.to_usize());
25 assert_eq!(enum_iterator::first::<Myenum>().unwrap(), Myenum::A);
26 assert_eq!(enum_iterator::last::<Myenum>().unwrap(), Myenum::C);
27 let mut i = enum_iterator::all::<Myenum>();
28 assert_eq!(i.next(), Some (Myenum::A));
29 assert_eq!(i.next(), Some (Myenum::B));
30 assert_eq!(i.next(), Some (Myenum::C));
31 assert_eq!(i.next(), None);
32 assert_eq!(enum_iterator::next (&Myenum::A), Some (Myenum::B));
33 assert_eq!(enum_iterator::previous (&Myenum::A), None);
34 assert_eq!(enum_iterator::next (&Myenum::B), Some (Myenum::C));
35 assert_eq!(enum_iterator::previous (&Myenum::B), Some (Myenum::A));
36 assert_eq!(enum_iterator::next (&Myenum::C), None);
37 assert_eq!(enum_iterator::previous (&Myenum::C), Some (Myenum::B));
38}Sourcefn from_u8(n: u8) -> Option<Self>
fn from_u8(n: u8) -> Option<Self>
Converts an u8 to return an optional value of this type. If the
value cannot be represented by this type, then None is returned.
Sourcefn from_u16(n: u16) -> Option<Self>
fn from_u16(n: u16) -> Option<Self>
Converts an u16 to return an optional value of this type. If the
value cannot be represented by this type, then None is returned.
Sourcefn from_u32(n: u32) -> Option<Self>
fn from_u32(n: u32) -> Option<Self>
Converts an u32 to return an optional value of this type. If the
value cannot be represented by this type, then None is returned.
Sourcefn from_u128(n: u128) -> Option<Self>
fn from_u128(n: u128) -> Option<Self>
Converts an u128 to return an optional value of this type. If the
value cannot be represented by this type, then None is returned.
The default implementation converts through from_u64(). Types implementing
this trait should override this method if they can represent a greater range.
Sourcefn from_f32(n: f32) -> Option<Self>
fn from_f32(n: f32) -> Option<Self>
Converts a f32 to return an optional value of this type. If the
value cannot be represented by this type, then None is returned.
Sourcefn from_f64(n: f64) -> Option<Self>
fn from_f64(n: f64) -> Option<Self>
Converts a f64 to return an optional value of this type. If the
value cannot be represented by this type, then None is returned.
The default implementation tries to convert through from_i64(), and
failing that through from_u64(). Types implementing this trait should
override this method if they can represent a greater range.
Dyn Compatibility§
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.