#[repr(transparent)]pub struct Integer(_);
Expand description
Implementations
sourceimpl Integer
impl Integer
sourcepub fn from_value(val: Value) -> Option<Self>
pub fn from_value(val: Value) -> Option<Self>
Return Some(Integer)
if val
is an Integer
, None
otherwise.
Examples
use magnus::{eval, Integer};
assert!(Integer::from_value(eval("0").unwrap()).is_some());
assert!(Integer::from_value(eval("9223372036854775807").unwrap()).is_some());
// not an int
assert!(Integer::from_value(eval("1.23").unwrap()).is_none());
sourcepub fn from_i64(n: i64) -> Self
pub fn from_i64(n: i64) -> Self
Create a new Integer
from an i64.
Examples
use magnus::{eval, Integer};
let res: bool = eval!("i == 0", i = Integer::from_i64(0)).unwrap();
assert!(res);
let res: bool = eval!("i == 4611686018427387904", i = Integer::from_i64(4611686018427387904)).unwrap();
assert!(res);
let res: bool = eval!("i == -4611686018427387905", i = Integer::from_i64(-4611686018427387905)).unwrap();
assert!(res);
sourcepub fn from_u64(n: u64) -> Self
pub fn from_u64(n: u64) -> Self
Create a new Integer
from a u64.
Examples
use magnus::{eval, Integer};
let res: bool = eval!("i == 0", i = Integer::from_u64(0)).unwrap();
assert!(res);
let res: bool = eval!("i == 4611686018427387904", i = Integer::from_u64(4611686018427387904)).unwrap();
assert!(res);
sourcepub fn to_i8(self) -> Result<i8, Error>
pub fn to_i8(self) -> Result<i8, Error>
Convert self
to an i8
. Returns Err
if self
is out of range for
i8
.
Examples
use magnus::{eval, Integer};
assert_eq!(eval::<Integer>("127").unwrap().to_i8().unwrap(), 127);
assert!(eval::<Integer>("128").unwrap().to_i8().is_err());
assert_eq!(eval::<Integer>("-128").unwrap().to_i8().unwrap(), -128);
assert!(eval::<Integer>("-129").unwrap().to_i8().is_err());
sourcepub fn to_i16(self) -> Result<i16, Error>
pub fn to_i16(self) -> Result<i16, Error>
Convert self
to an i16
. Returns Err
if self
is out of range for
i16
.
Examples
use magnus::{eval, Integer};
assert_eq!(eval::<Integer>("32767").unwrap().to_i16().unwrap(), 32767);
assert!(eval::<Integer>("32768").unwrap().to_i16().is_err());
assert_eq!(eval::<Integer>("-32768").unwrap().to_i16().unwrap(), -32768);
assert!(eval::<Integer>("-32769").unwrap().to_i16().is_err());
sourcepub fn to_i32(self) -> Result<i32, Error>
pub fn to_i32(self) -> Result<i32, Error>
Convert self
to an i32
. Returns Err
if self
is out of range for
i32
.
Examples
use magnus::{eval, Integer};
assert_eq!(eval::<Integer>("2147483647").unwrap().to_i32().unwrap(), 2147483647);
assert!(eval::<Integer>("2147483648").unwrap().to_i32().is_err());
assert_eq!(eval::<Integer>("-2147483648").unwrap().to_i32().unwrap(), -2147483648);
assert!(eval::<Integer>("-2147483649").unwrap().to_i32().is_err());
sourcepub fn to_i64(self) -> Result<i64, Error>
pub fn to_i64(self) -> Result<i64, Error>
Convert self
to an i64
. Returns Err
if self
is out of range for
i64
.
Examples
use magnus::{eval, Integer};
assert_eq!(eval::<Integer>("4611686018427387903").unwrap().to_i64().unwrap(), 4611686018427387903);
assert_eq!(eval::<Integer>("-4611686018427387904").unwrap().to_i64().unwrap(), -4611686018427387904);
assert!(eval::<Integer>("9223372036854775808").unwrap().to_i64().is_err());
assert!(eval::<Integer>("-9223372036854775809").unwrap().to_i64().is_err());
sourcepub fn to_isize(self) -> Result<isize, Error>
pub fn to_isize(self) -> Result<isize, Error>
Convert self
to an isize
. Returns Err
if self
is out of range
for isize
.
Examples
use magnus::{eval, Integer};
assert_eq!(eval::<Integer>("4611686018427387903").unwrap().to_isize().unwrap(), 4611686018427387903);
assert_eq!(eval::<Integer>("-4611686018427387904").unwrap().to_isize().unwrap(), -4611686018427387904);
sourcepub fn to_u8(self) -> Result<u8, Error>
pub fn to_u8(self) -> Result<u8, Error>
Convert self
to a u8
. Returns Err
if self
is negative or out of
range for u8
.
Examples
use magnus::{eval, Integer};
assert_eq!(eval::<Integer>("255").unwrap().to_u8().unwrap(), 255);
assert!(eval::<Integer>("256").unwrap().to_u8().is_err());
assert!(eval::<Integer>("-1").unwrap().to_u8().is_err());
sourcepub fn to_u16(self) -> Result<u16, Error>
pub fn to_u16(self) -> Result<u16, Error>
Convert self
to a u16
. Returns Err
if self
is negative or out
of range for u16
.
Examples
use magnus::{eval, Integer};
assert_eq!(eval::<Integer>("65535").unwrap().to_u16().unwrap(), 65535);
assert!(eval::<Integer>("65536").unwrap().to_u16().is_err());
assert!(eval::<Integer>("-1").unwrap().to_u16().is_err());
sourcepub fn to_u32(self) -> Result<u32, Error>
pub fn to_u32(self) -> Result<u32, Error>
Convert self
to a u32
. Returns Err
if self
is negative or out
of range for u32
.
Examples
use magnus::{eval, Integer};
assert_eq!(eval::<Integer>("4294967295").unwrap().to_u32().unwrap(), 4294967295);
assert!(eval::<Integer>("4294967296").unwrap().to_u32().is_err());
assert!(eval::<Integer>("-1").unwrap().to_u32().is_err());
sourcepub fn to_u64(self) -> Result<u64, Error>
pub fn to_u64(self) -> Result<u64, Error>
Convert self
to a u64
. Returns Err
if self
is negative or out
of range for u64
.
Examples
use magnus::{eval, Integer};
assert_eq!(eval::<Integer>("4611686018427387903").unwrap().to_u64().unwrap(), 4611686018427387903);
assert!(eval::<Integer>("-1").unwrap().to_u64().is_err());
assert!(eval::<Integer>("18446744073709551616").unwrap().to_u64().is_err());
sourcepub fn to_usize(self) -> Result<usize, Error>
pub fn to_usize(self) -> Result<usize, Error>
Convert self
to a usize
. Returns Err
if self
is negative or out
of range for usize
.
Examples
use magnus::{eval, Integer};
assert_eq!(eval::<Integer>("4611686018427387903").unwrap().to_usize().unwrap(), 4611686018427387903);
assert!(eval::<Integer>("-1").unwrap().to_usize().is_err());
Methods from Deref<Target = Value>
sourcepub unsafe fn to_s(&self) -> Result<Cow<'_, str>, Error>
pub unsafe fn to_s(&self) -> Result<Cow<'_, str>, Error>
Convert self
to a Rust string.
Safety
This may return a direct view of memory owned and managed by Ruby. Ruby may modify or free the memory backing the returned str, the caller must ensure this does not happen.
This can be used safely by immediately calling
into_owned
on the return value.
Examples
use magnus::{eval, QTRUE};
let value = QTRUE;
// safe as we neve give Ruby a chance to free the string.
let s = unsafe { value.to_s() }.unwrap().into_owned();
assert_eq!(s, "true");
sourcepub unsafe fn classname(&self) -> Cow<'_, str>
pub unsafe fn classname(&self) -> Cow<'_, str>
Return the name of self
’s class.
Safety
Ruby may modify or free the memory backing the returned str, the caller must ensure this does not happen.
This can be used safely by immediately calling
into_owned
on the return value.
Examples
use magnus::{eval, RHash};
let value = RHash::new();
// safe as we neve give Ruby a chance to free the string.
let s = unsafe { value.classname() }.into_owned();
assert_eq!(s, "Hash");
Trait Implementations
sourceimpl TryConvert for Integer
impl TryConvert for Integer
sourcefn try_convert(val: Value) -> Result<Self, Error>
fn try_convert(val: Value) -> Result<Self, Error>
val
into Self
.