Enum Nullable 

pub enum Nullable<T> {
    NotNull(T),
    Null,
}

Wrapper for handling potentially NULL values.

use extendr_api::prelude::*;
test! {
    use extendr_api::wrapper::Nullable::*;

    // Plain integer.
    let s1 = r!(1);
    let n1 = <Nullable<i32>>::from_robj(&s1)?;
    assert_eq!(n1, NotNull(1));

    // NA integer - error.
    let sna = r!(NA_INTEGER);
    assert_eq!(<Nullable<i32>>::from_robj(&sna).is_err(), true);

    // NA integer - option gives none.
    assert_eq!(<Nullable<Option<i32>>>::from_robj(&sna)?, NotNull(None));

    // NULL object.
    let snull = r!(NULL);
    let nnull = <Nullable<i32>>::from_robj(&snull)?;
    assert_eq!(nnull, Null);

    assert_eq!(r!(Nullable::<i32>::Null), r!(NULL));
    assert_eq!(r!(Nullable::<i32>::NotNull(1)), r!(1));
}

Variants

NotNull(T)

Null

Trait Implementations

impl<T: Clone> Clone for Nullable<T>

fn clone(&self) -> Nullable<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Nullable<T>

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

Formats the value using the given formatter.

impl<T> From<Nullable<T>> for Robj

where T: Into<Robj>,

fn from(val: Nullable<T>) -> Self

Convert a rust object to NULL or another type.

use extendr_api::prelude::*;
test! {
    assert_eq!(r!(Nullable::<i32>::Null), r!(NULL));
    assert_eq!(r!(Nullable::<i32>::NotNull(1)), r!(1));
}

impl<'a, T> FromRobj<'a> for Nullable<T>

where T: FromRobj<'a>,

fn from_robj(robj: &'a Robj) -> Result<Self, &'static str>

Convert an object that may be null to a rust type.

use extendr_api::prelude::*;
test! {
    let s1 = r!(1);
    let n1 = <Nullable<i32>>::from_robj(&s1)?;
    assert_eq!(n1, Nullable::NotNull(1));
    let snull = r!(NULL);
    let nnull = <Nullable<i32>>::from_robj(&snull)?;
    assert_eq!(nnull, Nullable::Null);
}

impl<T: PartialEq> PartialEq for Nullable<T>

fn eq(&self, other: &Nullable<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> StructuralPartialEq for Nullable<T>