Struct layout_2013::display_list::items::OpaqueNode

pub struct OpaqueNode(pub usize);

An opaque handle to a node, which, unlike UnsafeNode, cannot be transformed back into a non-opaque representation. The only safe operation that can be performed on this node is to compare it to another opaque handle or to another OpaqueNode.

Layout and Graphics use this to safely represent nodes for comparison purposes. Because the script task’s GC does not trace layout, node data cannot be safely stored in layout data structures. Also, layout code tends to be faster when the DOM is not being accessed, for locality reasons. Using OpaqueNode enforces this invariant.

Tuple Fields

0: usize

Implementations

impl OpaqueNode

pub fn id(&self) -> usize

Returns the address of this node, for debugging purposes.

Trait Implementations

impl Clone for OpaqueNode

fn clone(&self) -> OpaqueNode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for OpaqueNode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OpaqueNode

fn deserialize<__D>( __deserializer: __D, ) -> Result<OpaqueNode, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for OpaqueNode

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 MallocSizeOf for OpaqueNode

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 PartialEq for OpaqueNode

fn eq(&self, other: &OpaqueNode) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for OpaqueNode

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for OpaqueNode

impl Eq for OpaqueNode

impl StructuralPartialEq for OpaqueNode