Struct magnus::value::Fixnum

#[repr(transparent)]
pub struct Fixnum(_);

A Value known to be a fixnum, Ruby’s internal representation of small integers.

See also Integer.

All Value methods should be available on this type through Deref, but some may be missed by this documentation.

Implementations

impl Fixnum

pub fn from_value(val: Value) -> Option<Self>

Return Some(Fixnum) if val is a Fixnum, None otherwise.

Examples

use magnus::{eval, Fixnum};

assert!(Fixnum::from_value(eval("0").unwrap()).is_some());
// too big
assert!(Fixnum::from_value(eval("9223372036854775807").unwrap()).is_none());
// not an int
assert!(Fixnum::from_value(eval("1.23").unwrap()).is_none());

pub fn from_i64(n: i64) -> Result<Self, RBignum>

Create a new Fixnum from an i64.

Returns Ok(Fixnum) if n is in range for Fixnum, otherwise returns Err(RBignum).

Examples

use magnus::{eval, Fixnum};

assert!(Fixnum::from_i64(0).is_ok());
// too big
assert!(Fixnum::from_i64(4611686018427387904).is_err());
assert!(Fixnum::from_i64(-4611686018427387905).is_err());

pub fn from_u64(n: u64) -> Result<Self, RBignum>

Create a new Fixnum from a u64.

Returns Ok(Fixnum) if n is in range for Fixnum, otherwise returns Err(RBignum).

Examples

use magnus::{eval, Fixnum};

assert!(Fixnum::from_u64(0).is_ok());
// too big
assert!(Fixnum::from_u64(4611686018427387904).is_err());

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, Fixnum};

assert_eq!(eval::<Fixnum>("127").unwrap().to_i8().unwrap(), 127);
assert!(eval::<Fixnum>("128").unwrap().to_i8().is_err());
assert_eq!(eval::<Fixnum>("-128").unwrap().to_i8().unwrap(), -128);
assert!(eval::<Fixnum>("-129").unwrap().to_i8().is_err());

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, Fixnum};

assert_eq!(eval::<Fixnum>("32767").unwrap().to_i16().unwrap(), 32767);
assert!(eval::<Fixnum>("32768").unwrap().to_i16().is_err());
assert_eq!(eval::<Fixnum>("-32768").unwrap().to_i16().unwrap(), -32768);
assert!(eval::<Fixnum>("-32769").unwrap().to_i16().is_err());

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, Fixnum};

assert_eq!(eval::<Fixnum>("2147483647").unwrap().to_i32().unwrap(), 2147483647);
assert!(eval::<Fixnum>("2147483648").unwrap().to_i32().is_err());
assert_eq!(eval::<Fixnum>("-2147483648").unwrap().to_i32().unwrap(), -2147483648);
assert!(eval::<Fixnum>("-2147483649").unwrap().to_i32().is_err());

pub fn to_i64(self) -> i64

Convert self to an i64. This is infallible as i64 can represent a larger range than Fixnum.

Examples

use magnus::{eval, Fixnum};

assert_eq!(eval::<Fixnum>("4611686018427387903").unwrap().to_i64(), 4611686018427387903);
assert_eq!(eval::<Fixnum>("-4611686018427387904").unwrap().to_i64(), -4611686018427387904);

pub fn to_isize(self) -> isize

Convert self to an isize. Returns Err if self is out of range for isize.

Examples

use magnus::{eval, Fixnum};

assert_eq!(eval::<Fixnum>("4611686018427387903").unwrap().to_isize(), 4611686018427387903);
assert_eq!(eval::<Fixnum>("-4611686018427387904").unwrap().to_isize(), -4611686018427387904);

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, Fixnum};

assert_eq!(eval::<Fixnum>("255").unwrap().to_u8().unwrap(), 255);
assert!(eval::<Fixnum>("256").unwrap().to_u8().is_err());
assert!(eval::<Fixnum>("-1").unwrap().to_u8().is_err());

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, Fixnum};

assert_eq!(eval::<Fixnum>("65535").unwrap().to_u16().unwrap(), 65535);
assert!(eval::<Fixnum>("65536").unwrap().to_u16().is_err());
assert!(eval::<Fixnum>("-1").unwrap().to_u16().is_err());

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, Fixnum};

assert_eq!(eval::<Fixnum>("4294967295").unwrap().to_u32().unwrap(), 4294967295);
assert!(eval::<Fixnum>("4294967296").unwrap().to_u32().is_err());
assert!(eval::<Fixnum>("-1").unwrap().to_u32().is_err());

pub fn to_u64(self) -> Result<u64, Error>

Convert self to a u64. Returns Err if self is negative.

Examples

use magnus::{eval, Fixnum};

assert_eq!(eval::<Fixnum>("4611686018427387903").unwrap().to_u64().unwrap(), 4611686018427387903);
assert!(eval::<Fixnum>("-1").unwrap().to_u64().is_err());

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, Fixnum};

assert_eq!(eval::<Fixnum>("4611686018427387903").unwrap().to_usize().unwrap(), 4611686018427387903);
assert!(eval::<Fixnum>("-1").unwrap().to_usize().is_err());

Methods from Deref<Target = Value>

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

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

pub fn try_convert<T>(&self) -> Result<T, Error> where
    T: TryConvert, 

Convert self to the Rust type T.

See the types that TryConvert is implemented on for what this method can convert to.

Examples

use magnus::{eval, Value};

assert_eq!(eval::<Value>("42").unwrap().try_convert::<i64>().unwrap(), 42);
assert_eq!(eval::<Value>("1.23").unwrap().try_convert::<i64>().unwrap(), 1);
assert_eq!(eval::<Value>("1").unwrap().try_convert::<f64>().unwrap(), 1.0);
assert_eq!(eval::<Value>("nil").unwrap().try_convert::<Option<i64>>().unwrap(), None);
assert_eq!(eval::<Value>("42").unwrap().try_convert::<Option<i64>>().unwrap(), Some(42));

Trait Implementations

impl Clone for Fixnum

fn clone(&self) -> Fixnum

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Fixnum

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for Fixnum

type Target = Value

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Display for Fixnum

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Fixnum> for Value

fn from(val: Fixnum) -> Self

Converts to this type from the input type.

impl TryConvert for Fixnum

fn try_convert(val: &Value) -> Result<Self, Error>

Convert val into Self.

impl Copy for Fixnum

impl ReprValue for Fixnum