Struct Global

pub struct Global<T> { /* private fields */ }

An object reference that is independent of any handle scope. Where a Local handle only lives as long as the HandleScope in which it was allocated, a global handle remains valid until it is dropped.

A global handle contains a reference to a storage cell within the V8 engine which holds an object value and which is updated by the garbage collector whenever the object is moved.

You can create a v8::Local out of v8::Global using v8::Local::new(scope, global_handle).

Implementations

impl<T> Global<T>

pub fn new(isolate: &mut Isolate, handle: impl Handle<Data = T>) -> Self

Construct a new Global from an existing Handle.

pub fn into_raw(self) -> NonNull<T>

Consume this Global and return the underlying raw pointer.

The returned raw pointer must be converted back into a Global by using Global::from_raw, otherwise the V8 value referenced by this global handle will be pinned on the V8 heap permanently and never get garbage collected.

pub unsafe fn from_raw(isolate: &mut Isolate, data: NonNull<T>) -> Self

Converts a raw pointer created with Global::into_raw() back to its original Global.

pub fn open<'a>(&'a self, scope: &mut Isolate) -> &'a T

Trait Implementations

impl<T> Borrow<T> for Global<T>

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T> Clone for Global<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Global<T>

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

Formats the value using the given formatter.

impl<T> Drop for Global<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T> Handle for &'a Global<T>

type Data = T

fn open<'a>(&'a self, isolate: &mut Isolate) -> &'a Self::Data

Returns a reference to the V8 heap object that this handle represents. The handle does not get cloned, nor is it converted to a Local handle.

unsafe fn get_unchecked(&self) -> &Self::Data

Reads the inner value contained in this handle, without verifying that the this handle is hosted by the currently active Isolate.

impl<T> Handle for Global<T>

type Data = T

fn open<'a>(&'a self, isolate: &mut Isolate) -> &'a Self::Data

Returns a reference to the V8 heap object that this handle represents. The handle does not get cloned, nor is it converted to a Local handle.

unsafe fn get_unchecked(&self) -> &Self::Data

Reads the inner value contained in this handle, without verifying that the this handle is hosted by the currently active Isolate.

impl<T: Hash> Hash for Global<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, Rhs: Handle> PartialEq<Rhs> for Global<T>

where T: PartialEq<Rhs::Data>,

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

where T: Eq,