Struct magnus::Integer

source ·

pub struct Integer(/* private fields */);

Expand description

A type wrapping either a Fixnum or a RBignum.

See the ReprValue trait for additional methods available on this type. See Ruby for methods to create an Integer.

Implementations§

source §

impl Integer

source

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());

source

pub fn from_i64(n: i64) -> Self

Create a new Integer from an i64.

§Panics

Panics if called from a non-Ruby thread. See Ruby::integer_from_i64 for the non-panicking version.

§Examples

use magnus::{rb_assert, Integer};

rb_assert!("i == 0", i = Integer::from_i64(0));
rb_assert!(
    "i == 4611686018427387904",
    i = Integer::from_i64(4611686018427387904),
);
rb_assert!(
    "i == -4611686018427387905",
    i = Integer::from_i64(-4611686018427387905),
);

source

pub fn from_u64(n: u64) -> Self

Create a new Integer from a u64.

§Panics

Panics if called from a non-Ruby thread. See Ruby::integer_from_u64 for the non-panicking version.

§Examples

use magnus::{rb_assert, Integer};

rb_assert!("i == 0", i = Integer::from_u64(0));
rb_assert!(
    "i == 4611686018427387904",
    i = Integer::from_u64(4611686018427387904),
);

source

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());

source

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());

source

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());

source

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());

source

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
);

source

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());

source

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());

source

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());

source

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());

source

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());