Struct OptionalRef

pub struct OptionalRef<T: OptionalBlock> { /* private fields */ }

Implementations

impl<D: Dealloc> OptionalRef<AnyInternal<D>>

pub fn is<T: AnyCast<D>>(&self) -> bool

pub fn move_from<T: AnyCast<D>>(t: T) -> Self

T should have the same allocator as Any.

use nanvm_lib::{js::{any::Any, js_string::JsStringRef}, mem::{manager::Dealloc, ref_::Ref}};
fn dummy<A: Dealloc>(s: JsStringRef<A>) -> Any<A> {
    Any::move_from(s)
}

use nanvm_lib::{js::{any::Any, js_string::JsStringRef}, mem::{manager::Dealloc, ref_::Ref}};
fn dummy<A: Dealloc, B: Dealloc>(s: JsStringRef<A>) -> Any<B> {
    Any::move_from(s)
}

pub fn try_move<T: AnyCast<D>>(self) -> Result<T, ()>

pub fn get_type(&self) -> Type

pub fn try_ref<T: RefCast<D>>(&self) -> Result<&Block<T, D>, ()>

T should have the same allocator as Any.

use nanvm_lib::{js::{any::Any, js_string::JsStringRef}, mem::{manager::Dealloc, ref_::Ref}};
fn dummy<A: Dealloc>(a: Any<A>) -> JsStringRef<A> {
    a.try_move().unwrap()
}

use nanvm_lib::{js::{any::Any, js_string::JsStringRef}, mem::{manager::Dealloc, ref_::Ref}};
fn dummy<A: Dealloc, B: Dealloc>(a: Any<A>) -> JsStringRef, B> {
    a.try_move().unwrap()
}

pub fn for_each<E>( &self, f: impl FnMut(Any<D>, &Any<D>) -> Result<(), E>, ) -> Result<(), E>

Iterate trough children of this Any. Any type other than array / object yields nothing. For an object, first argument of f is the key string. For an array, it is the index.

impl<T: OptionalBlock> OptionalRef<T>

pub const unsafe fn from_internal(value: T) -> Self

pub const unsafe fn internal(&self) -> T

pub fn is_ref(&self) -> bool

pub unsafe fn move_to_internal(self) -> T

impl<T: Object, D: Dealloc> OptionalRef<*const Block<T, D>>

pub fn try_to_mut_ref(self) -> Result<MutRef<T, D>, Self>

Trait Implementations

impl<T: OptionalBlock> Clone for OptionalRef<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + OptionalBlock> Debug for OptionalRef<T>

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

Formats the value using the given formatter.

impl<T: OptionalBlock> Drop for OptionalRef<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: OptionalBlock> Hash for OptionalRef<T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: OptionalBlock> PartialEq for OptionalRef<T>

fn eq(&self, other: &Self) -> 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: OptionalBlock> Eq for OptionalRef<T>