Struct Root 

pub(crate) struct Root<T>
where
    T: StableTraceObject,
{
    value: T,
    root_list: *const RootCollection,
}

A rooted value.

Fields

value: T

root_list: *const RootCollection

Implementations

impl<T> Root<T>

where T: StableTraceObject + 'static,

pub unsafe fn new(value: T) -> Root<T>

Create a new stack-bounded root for the provided value. It gives out references which cannot outlive this new Root.

Safety

It must not outlive its associated RootCollection.

impl<T> Root<MaybeUnreflectedDom<T>>

where T: DomObject,

pub fn as_ptr(&self) -> *const T

impl<T> Root<MaybeUnreflectedDom<T>>

where T: MutDomObject,

pub unsafe fn reflect_with(self, obj: *mut JSObject) -> Root<Dom<T>>

Treat the given JS object as the reflector of this unreflected object.

Safety

obj must point to a valid, non-null JS object.

impl<T> Root<Dom<T>>

where T: Castable,

pub fn upcast<U>(root: Root<Dom<T>>) -> Root<Dom<U>>

where U: Castable, T: DerivedFrom<U>,

Cast a DOM object root upwards to one of the interfaces it derives from.

pub fn downcast<U>(root: Root<Dom<T>>) -> Option<Root<Dom<U>>>

where U: DerivedFrom<T>,

Cast a DOM object root downwards to one of the interfaces it might implement.

impl<T> Root<Dom<T>>

where T: DomObject,

pub fn from_ref(unrooted: &T) -> Root<Dom<T>>

Generate a new root from a reference

pub fn as_traced(&self) -> Dom<T>

Create a traced version of this rooted object.

Safety

This should never be used to create on-stack values. Instead these values should always end up as members of other DOM objects.

Trait Implementations

impl<T> Clone for Root<Dom<T>>

where T: DomObject,

fn clone(&self) -> Root<Dom<T>>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Root<T>

where T: Debug + StableTraceObject,

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

Formats the value using the given formatter.

impl<T> Deref for Root<T>

where T: Deref + StableTraceObject,

type Target = <T as Deref>::Target

The resulting type after dereferencing.

fn deref(&self) -> &<Root<T> as Deref>::Target

Dereferences the value.

impl<T> Drop for Root<T>

where T: StableTraceObject,

fn drop(&mut self)

Executes the destructor for this type.

impl<T> FromJSValConvertible for Root<Dom<T>>

where T: DomObject + IDLInterface,

type Config = ()

Optional configurable behaviour switch; use () for no configuration.

unsafe fn from_jsval( cx: *mut JSContext, value: Handle<'_, Value>, _config: <Root<Dom<T>> as FromJSValConvertible>::Config, ) -> Result<ConversionResult<Root<Dom<T>>>, ()>

Convert val to type Self. Optional configuration of type T can be passed as the option argument. If it returns Err(()), a JSAPI exception is pending. If it returns Ok(Failure(reason)), there is no pending JSAPI exception.

impl<T> Hash for Root<Dom<T>>

where T: DomObject,

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

where H: Hasher,

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> MallocSizeOf for Root<Dom<T>>

where T: DomObject + MallocSizeOf,

fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself.

impl<T> PartialEq for Root<Dom<T>>

where T: DomObject,

fn eq(&self, other: &Root<Dom<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> ToJSValConvertible for Root<Dom<T>>

where T: DomObject,

unsafe fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandle<'_, Value>)

Convert self to a JSVal. JSAPI failure causes a panic.

impl<T> Traceable for Root<Dom<T>>

where T: DomObject,

unsafe fn trace(&self, _: *mut JSTracer)

Trace self.

impl<T> Eq for Root<Dom<T>>

where T: DomObject,